AI Agent Engineer (Hisar)

The Role

DINX is building an agent-native business platform where autonomous AI agents run real business

workflows end-to-end — across logistics, finance, CRM, and operations — while keeping humans in

control at the decisions that matter.

The AI Agent Engineer owns the intelligence layer of that platform. You will design and implement

the agent org-chart — orchestrator, domain managers, and worker agents — defining how agents

are organised, how they decompose goals into tasks, and how they hand off work across domains

and to humans when it counts. You will own the integration contract between agents and every

platform component, and define where AI reasoning stops and deterministic execution takes over.

Beyond architecture, you will build the systems that make autonomous operation trustworthy in

production: safety boundaries, cost governance, observability, auditability, and human oversight

that is meaningful without being a bottleneck. This is a foundational role — the patterns and standards you establish here will carry across every vertical the platform enters.

What You Will Do

Agent Architecture & Implementation

- Design and implement a multi-tier agent hierarchy: an orchestrator that routes work across domains, domain managers that own a business area and decompose goals into tasks, and worker agents that execute specific tasks against platform components
- Define and implement escalation logic — when an agent resolves a problem autonomously up the chain, and when it stops and routes to a human for approval
- Build shared agent memory that gives agents the organisational context they need across domains while keeping each client's data strictly isolated
- Design context management so agents always have the right information to act — without overloading or exceeding model limits

MCP Integration

- Build and maintain the integration layer between agents and every platform component —communications, documents, payments, scheduling, identity, and approvals — through a single clean protocol
- Ensure agents interact with platform capabilities through well-defined tool interfaces, never through internal service logic or vendor APIs directly
- Write tool and resource definitions that are exact, machine-readable, and give agents exactly the context they need to act reliably

Reason-vs-Execute Boundary

- Design and enforce the boundary between what agents decide and what deterministic systems execute — agents trigger actions, validated engines run them
- Ensure that critical computations — pricing, invoicing, payments, booking state — are never left to LLM reasoning; they are handled by deterministic, validated execution
- Classify every agent-triggered action by its autonomy level and reversibility: what runs automatically, what requires a condition to be met, and what always requires a human decision

Cost Governance & Reliability

- Implement token and cost budgets at the agent and workflow level; set delegation depth limits and loop guards to prevent runaway agent behaviour
- Build anomaly detection and kill switch capability so agent workflows can be stopped or throttled when something goes wrong
- Instrument every agent run for latency, error rate, and spend — and surface cost-per-automated-process as a measurable unit-economics metric

Event-Driven Integration

- Integrate agent workflows with the platform's event-driven backbone — agents consume the current state of the world from projections and emit a structured record for every action they take: inputs, reasoning, decision, and outcome
- Design agent flows that handle the lag between a state change and its availability for reading — agents must never act on information that may already be out of date for state-sensitive decisions
- Contribute to event schema design with the broader engineering team; understand that event records are permanent and must be versioned and structured from the start

Required

- 4+ years of software engineering with at least 3 years building and shipping production AI agent systems
- Deep expertise in multi-agent system design: orchestration hierarchies, task decomposition, delegation, inter-agent communication, and multi-domain agent handoffs
- Strong command of agent frameworks (LangGraph, AutoGen, CrewAI, or equivalent) — knows the trade-offs, not just the syntax
- Experience designing and implementing escalation logic: autonomous up-the-chain escalation vs. human-gate triggers, and knowing clearly when each applies
- Advanced prompt engineering: structured outputs, chain-of-thought reasoning, few-shot design, tool-use routing, and context window management at scale
- Deep understanding of agent safety and control: where LLM reasoning must stop, where deterministic execution takes over, and how to enforce and maintain that boundary in a live
- system
- Experience with MCP or equivalent tool-server integration patterns: writing clean, machine-readable tool and resource definitions that agents can reliably consume
- Expertise in human-in-the-loop system design: gate routing, decision presentation, and keeping human oversight meaningful without making it a bottleneck
- Strong agent observability and auditability: every agent action structured and logged with inputs, rationale, and before/after state — making the system fully explainable and reconstructable
- Exception handling and autonomous recovery: agents resolving failures within policy boundaries, escalating correctly when outside them
- Reversibility thinking: classifying agent-triggered actions as reversible, compensating, or record-and-notify — and designing accordingly
- Real production experience with LLM cost governance: model selection and routing, token budgets, loop guards, delegation depth limits, kill switches, and spend anomaly detection
- LLM evaluation: testing agent behaviour, measuring reasoning quality, and detecting regressions in production
- Experience with long-running autonomous workflows: retry logic, compensation patterns, and process durability
- Solid understanding of event-driven and asynchronous systems: eventual consistency, and designing agent flows that do not act on stale state
- Background in CQRS or event sourcing architectures: understanding how state is derived from an immutable event log and how projections are consumed
- Agent security: prompt injection defence, sandboxing, and trust boundaries between agents and untrusted external content
- Master in Python
- Deep working knowledge of LLM SDKs — Anthropic, OpenAI, or equivalent — beyond
- surface API calls, understanding model behaviour, response handling, and failure modes
- Hands-on experience with observability and tracing tooling — LangSmith or equivalent instrumenting and debugging agent runs in production
- Hands-on experience with vector stores and semantic retrieval — Pinecone, Weaviate, pgvector, or equivalent
- Hands-on experience with LLM evaluation frameworks for testing agent behaviour, measuring reasoning quality, and catching regressions before they reach production

Good to Have

- Sufficient TypeScript / Node.js to consume platform APIs and write clean integration code alongside the backend engineer without creating blockers
- Familiarity with REST APIs, webhooks, and async messaging patterns
- Domain knowledge in logistics, supply chain, CRM, ERP, or financial back-office workflows Apply on Kit Job: kitjob.in/job/4n6bq0