Job Summary

The Agentic AI Engineer is responsible for designing and building the cognitive architecture of AI agents that interact with enterprise ERP systems. This is not prompt engineering - it is the design of agent behavior systems: how agents reason through ambiguous multi-step problems, when and how they use tools, how they coordinate with other agents, how they govern themselves within risk-tiered autonomy frameworks, and how they escalate to humans at the right moments.

This role sits at the intersection of AI engineering and enterprise systems architecture. Where the GenAI Engineer (junior/mid-level) focuses on individual prompt design, context window management, and LLM API integration, the Agentic AI Engineer designs the higher-order systems: multi-agent coordination patterns, cognitive reasoning chains for complex ERP workflows, dynamic tool selection strategies, autonomous vs. supervised decision boundaries, and the feedback loops that make agents learn from their operational experience.

This is an emerging discipline. The industry is evolving from simple prompt engineering toward what might be called agent behavior engineering, agentic systems design, or cognitive architecture. We are looking for someone who can help define what this role becomes. This role is based in India.

Responsibilities

Agent Cognitive Architecture

- Design the reasoning framework for how agents decompose complex ERP tasks into structured decision trees with governance checkpoints at each stage.
- Build agent personas and behavioral profiles for each Rimini Solution domain (Finance, Procurement, Supplier Management, Expense, Support) defining domain-specific reasoning patterns, risk tolerances, and escalation triggers.
- Architect energetic tool selection strategies where agents choose which MCP tools to invoke based on context, confidence, and task requirements rather than hardcoded sequences.
- Design conversation state management for long-running agent sessions that span multiple interactions, tool calls, and human-in-the-loop approvals.




- Build confidence scoring frameworks that translate LLM output uncertainty into actionable governance decisions (proceed, verify, escalate, halt).

Multi-Agent Coordination

- Design A2A (Agent-to-Agent) communication patterns for collaborative workflows where multiple specialized agents contribute to a single business outcome.
- Architect supervisor/worker agent hierarchies with clear delegation, progress monitoring, and result aggregation patterns.
- Build conflict resolution strategies for when agents produce contradictory assessments (e.g., risk agent says halt, efficiency agent says proceed).
- Design shared context and memory patterns that allow agent teams to build collective understanding of a business situation without redundant processing.

Autonomous Decision Governance

- Translate OPA policy definitions into agent-actionable decision boundaries - bridging the gap between policy-as-code and agent reasoning.
- Design the autonomy progression model: how agents earn increased autonomy through demonstrated accuracy, how trust degrades after errors, and how the system self-corrects.
- Build the explainability layer that enables agents to articulate their reasoning chain to human reviewers in business-meaningful terms.
- Design circuit breaker patterns at the cognitive level agents that recognize when they are outside their competence boundary and proactively escalate rather than guessing.

Knowledge Integration Institutional Memory

- Design retrieval-augmented reasoning patterns where agents dynamically pull relevant knowledge from vector stores, historical and knowledge data and approval pattern databases during their reasoning process.
- Build the feedback mechanisms that capture how experienced users correct or override agent recommendations, turning those corrections into improved future reasoning.

Agent Evaluation Quality





- Design evaluation frameworks for agent behavior - not just output accuracy but reasoning quality, appropriate escalation, governance compliance, and user trust metrics.
- Build scenario-based testing methodologies: synthetic ERP scenarios that test agent behavior across edge cases, ambiguous situations, and adversarial inputs.
- Define agent performance metrics: task completion rate, escalation accuracy, false positive/negative rates for autonomous decisions, time-to-resolution, and user override frequency.
- Own the continuous improvement loop: analyze production agent behavior, identify reasoning failures, and refine cognitive architecture to prevent recurrence.

Requirements

- 4-6 years of software engineering experience with strong Python and/or Java proficiency.
- 3+ years working with AI/ML systems in production, including LLM-based applications.
- 1+ years designing or building agentic AI systems - autonomous agents that reason, plan, use tools, and take actions (not just chatbots or simple RAG).
- Demonstrated experience with agent frameworks: LangChain/LangGraph, Pydantic AI, CrewAI, AutoGen, Semantic Kernel, or equivalent.
- Experience with tool-calling / function-calling patterns in LLMs (MCP, OpenAI function calling, Anthropic tool use).
- Understanding of evaluation methodologies for non-deterministic systems - testing outputs that arent binary right/wrong.
- Experience building systems that handle human-in-the-loop workflows - knowing when to pause for human judgment.

Technical Skills

- Advanced proficiency. Pydantic AI is primary agent framework; must be fluent.Python:
- Deep experience with Claude (Anthropic), GPT (OpenAI), or equivalent. Understanding of system prompts, tool calling, streaming, structured output.LLM APIs:
- Hands-on with at least one: Pydantic AI, LangChain/LangGraph

Disclaimer: This job posting and Location has been aggregated from external source. Role details, content, and availability are subject to change. Applicants are advised to confirm the latest information directly on the company website before applying.

📌 Agentic AI Engineer (Hyderabad)
🏢 Rimini Street
📍 Hyderabad