About the role
About The Team:
Our Engineering Team is at the forefront of this transformative journey, responsible for designing, building, and maintaining Aspire's exceptional products and infrastructure. We take pride in developing cutting-edge, digital-first technology solutions that simplify financial services for businesses.
About The Role:
We're hiring two Senior AI Engineers (Software Engineer III) for the OS Platform team in Gurgaon. Aspire OS is where AI becomes the way our customers run their finances: agents that reconcile, approve, pay, forecast, and explain, inside a regulated product where a wrong answer can move real money.
You'll build the foundation those agents run on: the model gateway, the agent runtime, tool and MCP integrations, retrieval and memory, evaluation, and the guardrails that make agents safe enough for a financial product. This is a hands-on role. You'll ship to production, own what you ship, and help set the standard for how Aspire builds with AI.
What You'll Be Doing:
- Build production agents and multi-step workflows on LangGraph, LangChain, or custom orchestration, with durable state, retries, and human approval for money-moving actions.
- Own the LLM gateway: routing and fallback across providers (OpenRouter, AWS Bedrock, and direct APIs), with cost, latency, and quality budgets, caching, rate limits, and per-tenant controls.
- Build MCP servers and tool interfaces that let agents act safely on Aspire's banking, cards, payments, and accounting capabilities.
- Design RAG pipelines, agent memory, and reusable agent skills, and manage context windows deliberately.
- Build the guardrails and policy layer: input and output validation, prompt-injection defenses, PII redaction, policy-as-code, action and spend limits, and audit trails that stand up to regulators.
- Run the agent development lifecycle (ADLC) end to end: spec, eval-first build, guardrail review, staged rollout, monitoring, and iteration.
- Cut latency and cost through streaming, caching, batching, parallel tool calls, and model right-sizing, against p95 and cost-per-task targets you own.
- Write production Python and Go, deploy on AWS with solid CI/CD and observability, and raise the bar for the team through code and design reviews.
About You:
What we're looking for:
- 5 to 8 years in software engineering, including at least 2 years building and shipping LLM-powered systems to production.
- Strong full-stack engineering: fluent in Python and at least one of Go or TypeScript, with experience designing and running backend services and APIs at scale.
- Hands-on agent building: tool use, planning, memory, and multi-step orchestration with LangChain, LangGraph, or equivalent, plus MCP servers or clients.
- Deep working knowledge of LLMs: model trade-offs, context windows, structured output, function calling, retrieval versus fine-tuning, and failure modes such as hallucination and prompt injection.
- Production experience with RAG and vector databases (pgvector, OpenSearch, Pinecone, or similar).
- Experience running an LLM gateway or router (OpenRouter, LiteLLM, or in-house), including fallback, cost control, and caching.
- Experience building guardrails, policy enforcement, and evaluation frameworks for AI systems.
- A track record of measurably reducing latency or cost in a production system.
- Production AWS experience with infrastructure as code, CI/CD, and observability (Datadog or similar).
- Experience in fintech or another regulated industry, with working knowledge of payments, ledgers, KYC/KYB, or compliance constraints.
The AI stack you'll work with:
You won't need every item below, but you should understand the trade-offs in each and have real depth in several.
- RAG: ingestion and chunking, embedding selection, hybrid search, re-ranking, query rewriting, grounded answers with citations, GraphRAG, and retrieval evaluation (recall@k, faithfulness).
- Agent memory: working memory within a run, long-term episodic and semantic memory, per-user and per-tenant scoping, summarization and context compaction, and PII-safe retention.
- Agent skills: reusable skill packages (instructions, scripts, and resources), progressive loading to protect the context window, skill and tool registries, versioning, and testing.
- ADLC: prompts, tools, and agent graphs treated as versioned, tested artifacts, released through evals, canaries, and rollback.
- Orchestration: LangGraph and LangChain, state machines, multi-agent patterns (supervisor, handoff, agent-to-agent), planning and reflection, durable execution (Temporal or AWS Step Functions).
- MCP and tool use: secure MCP servers and clients, per-tool authorization, tool schema design, function calling, and structured outputs.
- Models and routing: frontier and open-weight models, reasoning versus non-reasoning trade-offs, OpenRouter and AWS Bedrock, cost-aware routing, fine-tuning, and distillation where they pay off.
- Context and latency: context budgeting, prompt and semantic caching, streaming, batching, parallel tool calls, and awareness of quantization and speculative decoding.
- Evaluation and observability: golden datasets, calibrated LLM-as-judge, regression suites in CI, tracing and cost tracking (Langfuse, LangSmith, Braintrust, OpenTelemetry), drift detection.
- Safety and policy: guardrail frameworks, prompt-injection and jailbreak defenses, PII redaction, policy-as-code (OPA or Cedar), red-teaming, immutable audit trails.
- Data and documents: vector stores, document intelligence (OCR, invoice and statement extraction), and multimodal inputs.
- AI-assisted engineering: daily use of agentic coding tools such as Claude Code or Cursor, spec-driven development, and the judgment to know when not to trust the output.
Nice to have:
- Fine-tuning, distillation, or self-hosting open-weight models (vLLM, Bedrock, SageMaker).
- Experience with multi-agent systems or computer-use agents.
- Familiarity with financial regulation and model risk expectations (MAS, SOC 2, PCI DSS, GDPR) as they apply to AI.
- Open-source contributions, writing, talks, or side projects that show you build with AI for the love of it.
How You Work:
- You execute independently. Give you an ambiguous problem and you come back with a working system. You unblock yourself and finish what you start.
- You take the initiative. You spot a problem, validate it with data, and propose the fix before anyone assigns it.
- You stay curious about AI. You try new models and tools the week they ship, and tell the team what is worth adopting and what is hype.
- You are self-driven. You set your own bar and measure your own impact.
- You are a polyglot. You choose the language that fits the problem, whether Python, Go, or TypeScript.
- You build safety in. You treat customer money and data with care and add guardrails from the first commit, not after an incident.
- You communicate clearly. You write short, precise design docs and explain trade-offs to engineers, product, and risk partners alike.
What Success Looks Like:
- First 30 days: you ship a production change to the agent platform and know the gateway, guardrail, and evaluation setup well enough to review others' work.
- First 90 days: you own one platform component end to end, such as the MCP tool layer, retrieval, memory, or the eval pipeline, and deliver a measurable gain in latency, cost, or answer quality on a live Aspire OS agent.
- First 12 months: product teams come to you when they want to put an agent in front of customers safely, and the platform gives them paved paths they can follow on their own.