Applied AI Engineer – Agentic AI & Automation

Xpedeon; Mumbai; On-site; INR 1,800,000 - 3,000,000; Full time

Job summary

Xpedeon is seeking an Applied AI Engineer to extend our AI platform with agents that perform real actions across tools and APIs. You will design safe, multi-step execution loops, implement a robust tool-calling layer, and define strict authorization so agents operate within auditable boundaries.

You will prioritize reliability, idempotency, and failure handling and collaborate with product and ops to shape the automation scope while ensuring clear audit trails and governance.

Qualifications

• 3+ years of professional software engineering experience with backend focus.
• Experience building systems that call external APIs with real side effects.
• Experience designing idempotent and safe retries in distributed systems.
• Experience with authorization/permission modeling and centralized enforcement.
• Hands-on with LLM tool-calling APIs and orchestration logic.
• Strong failure-mode thinking: handle duplicates, order issues, partial failures.
• Experience building audit/logging systems for post-incident reconstruction.
• Clear written communication documenting explicitly out-of-scope actions and reasons.

Responsibilities

• Design and build multi-step agent execution loops that plan, call tools, observe results, and adapt.
• Build the tool-calling layer with strict schemas and validation on every invocation.
• Define authorization scope so actions stay within auditable allowlists.
• Create human-in-the-loop approval flows for safe auto-execution.
• Ensure idempotent and resumable tasks with rollback/compensation where needed.
• Develop comprehensive audit logs detailing actions, results, and rationales.
• Implement rate limiting, circuit breakers, and hard-stop conditions.
• Write tests simulating multi-step tasks and deliberate failures.
• Collaborate with product/ops to define automation scope.
• Monitor production agents and alert on anomalies.

Skills

Python backend

API integration

Idempotent design

Authorization modelling

LLM tool-calling APIs

Failure-mode thinking

Audit/logging design

Technical writing

Tools

LangGraph

temporal.io

OpenAI API

Vertex AI

Job description

About Us: Xpedeon is an integrated purpose-built ERP Suite contributing to digital transformation in the construction and engineering industry across the globe.

Backed by more than two decades of industry experience, Xpedeon has been helping businesses to scale up efficiency, increase profitability, and maximize margins in today’s dynamic business environment. Our integrated solution stack addresses the unique requirements and challenges of building contractors, civil engineering contractors, specialist contractors, and housebuilders by simplifying their business systems with our powerful, comprehensive suite.

More than 30,000 users have gained quantum leaps in productivity and control, improving their operational efficiency and growing their bottom line with Xpedeon.

Job Description: Applied AI Engineer - Agentic AI & Automation

Reports to: Engineering Lead

Level: Mid–Senior

About the role

We're extending our AI platform beyond answering questions into agents that take real action on a user's behalf executing multi-step tasks, calling internal and external tools/APIs, and completing work that has actual consequences if done wrong. This is a different discipline from building a Q&A or retrieval system: the central engineering problem is safety and reversibility under autonomy, not just answer quality. You'll design how the agent decides what it's allowed to do, how it recovers when a multi-step task fails partway through, and when it must stop and ask a human before proceeding.

What you'll do

• Design and build multi-step agent execution loops that plan, call tools/APIs, observe results, and adapt not single-shot prompt/response.
• Build the tool-calling layer: define what actions an agent can take, with strict schemas and validation on every tool invocation before it executes.
• Design authorization and scoping so an agent can only take actions within an explicit, auditable allowlist never inferring permission from context or "the user probably meant."
• Build human-in-the-loop approval flows: identify which actions are safe to auto-execute versus which require explicit user/operator confirmation before running and design the UX/API for that checkpoint.
• Design for partial failure: make multi-step tasks idempotent and resumable, so a crash or timeout mid-task doesn't leave data in an inconsistent or duplicated state and build rollback/compensating actions where true undo isn't possible.
• Build comprehensive audit logging of every action an agent takes what it decided, what tool it called, what the result was, and why sufficient to reconstruct and explain any outcome after the fact.
• Implement rate limiting, circuit breakers, and hard stop conditions so a misbehaving agent loop can't run away (excessive retries, repeated failed actions, runaway cost/API usage).
• Write test suites that simulate multi-step task execution, including deliberate failure injection at each step, to prove the agent handles partial failure and unauthorized-action attempts correctly not just that the happy path works.
• Collaborate with product/ops stakeholders to define which actions are in scope for automation at all, and which should remain human-only regardless of technical feasibility.
• Monitor agents in production for anomalous behavior (unexpected tool calls, repeated failures, actions outside historical patterns) and build alerting around it.

Required qualifications

• 3+ years of professional software engineering experience, with strong backend proficiency (Python or comparable).
• Experience building systems that call external or internal APIs with real side effects — not read-only integrations. (Payments, provisioning, order/workflow systems, infra-automation, RPA any domain where "the call executed" matters.)
• Experience designing for idempotency and safe retries in distributed or multi-step systems.
• Experience with authorization/permission modeling scoping what a given actor (human or automated) is allowed to do and enforcing it centrally rather than trusting caller intent.
• Hands-on experience with LLM tool-calling/function-calling APIs and building the orchestration logic around them (not just prompting a chat model).
• Strong instincts for failure-mode thinking given any action, can you name what goes wrong if it runs twice, runs out of order, or fails halfway and design for it up front.
• Experience building audit/logging systems sufficient for post-incident reconstruction, not just debug-level logs.
• Clear written communication comfortable documenting which actions are explicitly out of scope for automation and why, not just what the agent can do.

Preferred qualifications

• Experience with an agent orchestration framework (e.g., LangGraph, temporal.io or another workflow/durable-execution engine, custom state machines for long-running tasks).
• Experience with a major LLM provider's tool-use/function-calling implementation (Google Vertex AI/Gemini, OpenAI, Anthropic, AWS Bedrock).
• Background in a regulated or high-stakes automation domain (fintech, healthcare ops, infra/SRE automation) where "irreversible action taken incorrectly" has real cost.
• Experience building approval-queue or review UIs for pending automated actions.
• Familiarity with our existing read-only AI pipeline (RAG/retrieval-based Q&A) useful for context, not required, since this role's core skills are distinct from that track.

What we're explicitly not looking for

• Prompt-engineering-only experience without systems/backend engineering depth.
• Experience limited to read-only/analytics AI (retrieval, Q&A, reporting) without any exposure to systems that mutate state that's the adjacent, but distinct, role on our team.
• Comfort automating actions without designing explicit guardrails first this role requires a "prove it's safe" default, not a "ship it and monitor" default.

Success in the first 90 days

• Ship one end-to-end automated action (or a scoped subset of one) with an explicit permission boundary, idempotency handling, and full audit logging in production.
• Deliver a failure-injection test suite for at least one multi-step task that proves correct behavior under partial failure.
• Define and document, with product/ops input, the current allowlist/denylist of actions the agent is authorized to take and the escalation path for anything outside it.

Seniority notes

• Mid-level: implements individual tool integrations and action flows under an established authorization/approval framework.
• Senior/lead: owns the authorization model, approval-flow architecture, and failure-handling standards as the set of automatable actions grows; makes the call on what should never be automated.