The Builder-2 (Dev) Profile

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.

- 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.
- 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.

- 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 UX/Interaction Builder (Product) — the chatbox is just the beginning. You build generative UIs and browser-use agents that navigate existing portals to get work done.
- 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 contemporary 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.

📌 Builder Developer II (Hyderabad)
🏢 Eci Software Solutions
📍 Hyderabad