Builder Developer II

ECI Software Solutions; Hyderabad; On-site; INR 1,800,000 - 3,000,000; Full time

Job summary

ECI Software Solutions is seeking a full-time Full-Stack Agent Engineer in Hyderabad to design, build, debug, deploy, and maintain autonomous agents that navigate complex ERP schemas. You will drive AI-native workflows, implement robust retries, timeouts, and state recovery, and ensure reliability across long-running processes.

Responsibilities include prototyping new AI-driven features, automating legacy logic with AI-based tests and documentation, and proving parity with existing systems while

Responsibilities

• Build execution agents that navigate ERP schemas and fix data discrepancies.
• Automate legacy business logic with AI-driven tests and documentation.
• Prove parity by comparing old and new code paths across edge cases (fiscal calendar, multi-currency).
• Perform prompt engineering and evals to optimize instructions and outcomes.
• Prototype features quickly to turn what-if scenarios into working AI-driven capabilities.
• Fix production issues by reading traces and preventing recurrence.

Job description

You are a full-stack agent engineer. You can take a complex business requirement and build the multi-step AI workflow that solves it, end to end, without someone breaking it down for you first.

1. Core DNA

AI-Native Workflow. You use AI to accelerate development, testing and documentation as a default, not an experiment. You have opinions about which tools earn their place.

Agentic Implementation. You build, debug and deploy autonomous agents (LangGraph, AutoGen, Playwright-LLM hybrids) that navigate complex ERP schemas and long-running business logic.

Legacy-to-Modern Bridge. You treat 20-year-old systems as puzzles for AI-driven modernization, not as someone else’s problem.

Evidence Over Confidence. You don’t ship an agent because the demo went well. You ship it because you can show what it does on the edge cases — and you know your own error rate rather than claiming there isn’t one.

2. What You Own

Your agent. Design, build, debug, deploy, and keep running. Including the unglamorous parts: retries, state recovery, timeouts, what happens when the model is down.

The evidence it works. Before you refactor an undocumented module, you capture what it currently does — characterization tests, real inputs, real outputs. After, you show the behaviour matches. Your Builder 3 sets the standard; meeting it is your job, not theirs.

Your blast radius. You know exactly what your agent is permitted to touch, and you build so a wrong answer costs a review comment rather than a bad ledger entry.

3. Your Elective Specialty (lean into one)

The Agentic Architect (Systems) — you don’t just build APIs, you build tool-calling interfaces and state management for agentic graphs that survive long-running business processes.

The Data & Context Engineer (Data) — master of the RAG pipeline. Vector stores, chunking strategy, and knowledge graphs that teach the AI how a Purchase Order relates to a GL entry.

The Reliability & Eval Engineer (QA) — you move the team from prompt vibes to prompt engineering. DSPy for programmatic optimization, red-teaming agents to pressure-test financial logic.

The Infra & Agent-Ops Builder (DevOps) — you build the factory where agents live: tracing, logging and monitoring the thoughts of the AI.

The Domain Logic Translator (Business) — you take 50 pages of accounting regulation and turn it into structured system prompts and agentic constraints.

What You’ll Actually Do

Build execution agents. Move beyond RAG into action — agents that navigate an ERP schema, find a data discrepancy and propose the fix.

Automate the untestable. Wrap legacy business logic in modern tests and documentation using AI, starting with the modules everyone else has avoided.

Prove parity. Capture what the old code does before you replace it, and show the new path matches — on the boring cases and the fiscal-calendar, multi-currency, partial-shipment ones.

Prompt engineering and evals. Use frameworks like DSPy to move from vibes-based prompting to programmatic, optimized instructions.

Rapid prototyping. Turn a “what if” into a working AI-driven feature in days, not months.

Fix your own agents in production. Read the traces, find why it went sideways, make it not happen again.

What Good Looks Like

(Illustrative — real targets agreed with the hiring manager.)

30 days: Shipped your first agentic workflow into a real environment, however small.

90 days: Owning a legacy module end to end — parity evidence, tests, deployment — with minimal supervision.

6 months: Other Builders are reusing patterns you built. You’re the person people ask about one thing in particular.

The Stack

Python, SQL (Postgres/SQL Server), TypeScript, OpenAI/Anthropic, agentic coding tools, LangChain/LangGraph, DSPy, pgvector/Qdrant, dbt, Apache Hop/Airflow, Docker, Playwright, Weights & Biases, OpenTelemetry, eval and tracing platforms (LangSmith / Langfuse / Braintrust or equivalent). And any other tool that helps us achieve greatness.

Who You Are

You’ve shipped one. You have built at least one autonomous agent or complex LLM workflow that real people used for real work — not a weekend demo. You know how it failed, because it did.

The early adopter. You were using GPT-3 before it was cool and had a local model running the week it leaked. More time on r/LocalLLaMA, GitHub Trending and AI Twitter than on LinkedIn.

Agent-first thinker. You think in capabilities and failure modes, not functions.

The manual-task hater. You have a physical reaction to repetitive work. If you do it twice, you’ve already started drafting the automation.

Technically fearless. A 500-table undocumented legacy schema isn’t complexity, it’s a puzzle about to get solved. You aren’t intimidated by spaghetti code — you’re the one who brings the sauce.

Rigor over hype. You love the new models and you still ask for the numbers. You know the difference between a cool demo and a production-grade agent handling financial data.

Why Join Us

The Final Boss of complexity. ERPs are the ultimate challenge for AI. Automate a General Ledger or a global supply chain and you’ve mastered the hardest problem in software.

Agentic autonomy. We don’t do tickets. We do missions. You’ll have real freedom over the models, frameworks and agent architectures you think will win.

No red tape. If the agent works and the evals pass, we ship. No Change Management Committee — a “Does It Work?” policy.

The Builder Tribe. You won’t be the only AI person in the room. You’ll be part of a small squad of people equally obsessed with moving faster, where your automation hacks are your biggest contribution rather than a hidden side project.