senior AI Engineer

PalTech; Hyderabad; Presencial; INR 4.000.000 - 7.000.000; Jornada completa

Descripción de la vacante

PalTech is seeking a Senior AI Engineer to lead enterprise-grade autonomous agent systems. You will design stateful AI workflows, integrate MCP, and orchestrate complex business logic with LangGraph and LangChain.

You will apply strong Python backend skills, deploy production-ready microservices with FastAPI, and leverage Claude Code and other tooling to ship high-velocity, robust software while enforcing safety guardrails.

Formación

• 4+ years of backend Python experience with asyncio and clean architecture.
• 2+ years building autonomous agents and stateful graphs with LangGraph and LangChain.
• Hands-on MCP server development and integration with agent runtimes.
• Proficiency with Claude Code or similar agentic tooling for testing and rapid development.

Responsabilidades

• Agentic Orchestration & Graph Workflows: design, build, deploy multi-agent systems and stateful workflows.
• Tool Layer Standardization (MCP): deploy and maintain MCP servers and interfaces for safe internal access.
• Hybrid Automation Architecture: connect Python microservices with workflow engines (n8n) for end-to-end automation.
• Production API & Systems Development: develop asynchronous microservices (FastAPI), with rate limiting, streaming, retries, and token-cost tracking.
• AI-Native Engineering: leverage Claude Code and other tools to scaffold, test, and refactor code.
• Agent Reliability & Guardrails: implement safety guardrails, schema validation, and evaluation suites.

Conocimientos

Python backend development

Asynchronous programming (asyncio)

LangGraph / LangChain

Model Context Protocol (MCP)

Claude Code / agentic tooling

API design / FastAPI

System design

Testing/debugging with CLI tools

Herramientas

FastAPI

Docker

Kubernetes

Redis

SSE/WebSocket

Pydantic

JSON Schema

Descripción del empleo

Job Description

Role Overview

We are looking for a Senior AI Engineer to lead the development of enterprise-grade, autonomous agentic systems. In this role, you will build stateful AI workflows, standardize external tool connectivity using the Model Context Protocol (MCP), and orchestrate complex business logic using frameworks like LangGraph combined with workflow platforms like n8n. The ideal candidate combines strong Python backend fundamentals with deep AI expertise. You are someone who already uses next-generation AI-assisted developer tooling (such as Claude Code) to ship clean, production-ready code with high velocity.

Key Responsibilities

• Agentic Orchestration & Graph Workflows: Design, build, and deploy multi-agent systems and stateful, cyclic reasoning workflows using LangGraph and LangChain (handling memory, subgraphs, recursion limits, and human-in-the-loop interrupts).
• Tool Layer Standardization (MCP): Architect, deploy, and maintain custom Model Context Protocol (MCP) servers and client interfaces to give agents safe, standardized access to internal databases, APIs, and enterprise systems.
• Hybrid Automation Architecture: Bridge custom Python microservices with workflow automation engines like n8n to automate complex end-to-end multi-app processes and webhook-driven event pipelines.
• Production API & Systems Development: Develop robust, asynchronous microservices and endpoints (FastAPI) incorporating rate limiting, streaming responses (SSE/WebSocket), retries, and token-cost tracking.
• AI-Native Engineering: Champion AI-assisted development practices by heavily utilizing Claude Code and other agentic developer CLI tools to rapidly scaffold, test, and refactor code.
• Agent Reliability & Guardrails: Implement safety guardrails, schema validation, structured output enforcement, and automated agent evaluation suites (evaluating tool-call accuracy, task completion, and hallucination rates).

Required Skills & Qualifications

• Core Engineering Experience: 4+ years of professional backend software engineering in Python, with strong proficiency in asynchronous programming (asyncio, httpx), OOP, and clean architecture.
• Agentic Frameworks: 2+ years of hands-on experience building autonomous agents and stateful graphs using LangGraph (managing checkpointers, state schemas, and branch conditions) and LangChain.
• Model Context Protocol (MCP): Hands-on experience building, debugging, and deploying custom MCP servers (Stdio/SSE transports) and connecting them to agent runtimes.
• Modern Agentic Tooling: Daily fluency with Claude Code or comparable agentic CLI tools for automated testing, debugging, and rapid development.
• Structured Outputs & Tool Calling: Deep understanding of function/tool calling mechanics and schema enforcement libraries (e.g., Pydantic, Instructor, JSON Schema).
• RAG & Search: Solid foundation in Retrieval-Augmented Generation (RAG) architectures: hybrid search (dense embeddings + sparse keyword search), re-ranking, and production vector stores (e.g., Qdrant, Weaviate, Pinecone, or pgvector).
• System Design & Resilience: Strong system design fundamentals: API authentication, asynchronous task queues (Celery/Redis), rate-limiting, and error-recovery patterns for non-deterministic systems.

Preferred / Nice-to-Have

• In-House LLM Serving: Experience integrating with or deploying local/open-source models using engines like vLLM, Ollama, or Triton Inference Server on internal GPU infrastructure.
• Observability & LLMOps: Experience setting up end-to-end agent tracing, cost analysis, and evaluation frameworks using LangSmith, Arize Phoenix, or OpenTelemetry.
• Cloud Platforms: Experience running and containerizing AI services on AWS, Azure, or GCP using Docker and Kubernetes.
• MCP Open Source Ecosystem: Active contributor to or early adopter of the open-source MCP community and servers.
• Frontend Basics: Working familiarity with frontend frameworks (React, Next.js, or Tailwind) to quickly prototype internal agent-interaction UIs.