Senior AI Engineer — CIFx Platform

About the role

CIFx is our internal Replit-like vibe coding environment for building legal workflow applications that scale across the enterprise. We're building the platform that lets teams compose, deploy, and iterate on compound AI systems against our internal data and services — using a monorepoframework with NextJS on the frontend and NestJS on the backend.

This is a hands-on, IC-heavy role. You'll be taking ambiguous problems, decomposing them into compound systems of agents, retrieval layers, and deterministic services, and shipping them end-to-end. You won't be writing tickets for someone else to implement.

You'll be the person who can argue why a particular node in the graph needs Aurora-backed persistence instead of in-memory state, why your retriever needs sparse signals alongside dense embeddings, and why a specific latency budget is non-negotiable.

We care about good engineering principles over specific language fluency. NextJS and NestJSare the stack, but if you've built compound systems well elsewhere, you'll be productive here within weeks.

What you'll do

- Take legal workflow problems from "vague business ask" to "deployed, observable, evaluated compound system" — owning the decomposition, the architecture, the implementation, and the iteration loop
- Design and build multi-step agentic workflows in LangGraph (or equivalent), with thoughtful state management, human-in-the-loop checkpoints, and durable memory across sessions
- Build and evolve the retrieval layer — choosing dense, sparse, hybrid, or late-interaction strategies based on actual query distribution and document characteristics, not framework defaults
- Own production deployment end-to-end: CI/CD,



observability, evaluation harnesses, and the feedback loops that catch regressions before users do
- Drive technical depth across the team — push back on shallow architectures, model the right trade-offs, and raise the bar for what "production-ready AI" means here

What we're looking for

- Strong CS programming background. You think in terms of latency, runtime complexity, and failure modes — not just "does it work on my laptop"
- Hands-on production experience building agentic systems in LangGraph (or genuinely comparable graph-based orchestration). You can speak to state design, checkpointing, memory persistence, and how you handle human overrides mid-execution
- Real depth on embeddings and retrieval. You understand the trade-offs between dense, sparse (BM25-family), and late-interaction (ColBERT-style) retrieval, and you've made deliberate choices about when each wins. RRF and hybrid ranking aren't recent vocabulary to you
- Fluent with modern coding agents (Claude Code, Cursor, Cline, or similar). You use them as a force multiplier, not a crutch — you know when to trust them and when to take the keyboard back
- End-to-end ownership instinct. You have at least one personal or production project where you went from idea to deployment, including CI/CD and basic observability, without being asked to

Preferred





- Experience with the memory subsystem of agentic apps — short-term vs long-term, episodic vs semantic, and the architectural reasons to separate them
- Hands-on with MCP (Model Context Protocol) servers or comparable tool-integration patterns for exposing enterprise systems to LLMs
- Familiarity with evaluation approaches for LLM systems (faithfulness, groundedness, nDCG, RAGAS, or equivalent) — you don't ship blind

Nice to have

- TypeScript / NextJS / NestJS experience. Useful but not a gate — language concerns are secondary to engineering principles
- Exposure to fine-tuning (LoRA, DPO, PEFT) and a sense of when fine-tuning is the right answer vs better retrieval or better prompts
- Legal, compliance, or regulated-domain context

How we'll evaluate

Our interview is designed to surface the depth signals above, not pattern-match on buzzwords. Expect to be asked to:

- Decompose a real compound system problem from scratch and defend your boundaries
- Walk through the write and read paths of an agentic memory subsystem you've actually built
- Argue for a specific retrieval strategy against your real query distribution
- Show how you'd instrument and debug a latency regression in a multi-agent flow

If you've been on the building side of these problems, you'll enjoy this conversation. If you've only been on the integrating side, this probably isn't the right role.

What you won't find here

- Vague "AI strategy" work — we ship
- Wrapping yet another RAG around yet another corpus — we expect you to push the architecture forward
- Permission-asking culture — proactive ownership is the baseline expectation

📌 AI Engineer (Haryana)
🏢 Momento Cybertech Solutions
📍 Haryana