Senior AI Engineer

Blaugarnet Inc.; Pune District; Hybrid; INR 3,000,000 - 5,000,000; Full time

Job summary

Blaugarnet Inc. is building the Intent Layer for AI-driven software — a layer that sits above coding tools your team already loves and below business strategy. AI can write code, but it must align with business intent, with a governed, human-in-the-loop system that records every decision.

Our enterprise product is live in early access, small, and moving fast. The role is a hands-on senior engineering position at the core of the product.

Qualifications

• 4-6 years of software engineering experience.
• Backend development with Python/FastAPI.
• 2-3 years building AI/GenAI systems in production.
• Deterministic orchestration of LLM workflows.
• Guardrails enforced outside the model.
• RAG in production with vector search.
• Relational data modeling with Postgres.
• LLM API integration (OpenAI, Gemini, Anthropic).
• Async programming and solid API design.
• Docker, Git, and CI/CD workflows.

Responsibilities

• Design and build the core LLM reasoning and orchestration engine.
• Architect enterprise RAG pipelines over structured and unstructured data.
• Develop AI automation pipelines and data-quality logic.
• Build and maintain backend services powering AI apps.
• Make AI systems trustworthy in production with guardrails.
• Own cost and performance: token tracking and budgeting.
• Build MCP-compatible tools and integrations across providers.
• Own CI/CD and containerised deployment of AI services.
• Raise the bar through code reviews and deep-dives.
• Stay close to customer context and shape what we build.

Skills

Software engineering

Backend development

Python

FastAPI

Async programming

LLM workflows

RAG production

SQL/Postgres

LLM API integration

Evaluation frameworks

Cost/performance judgment

Startup mindset

Tools

Docker

Git

GitHub Actions

PostgreSQL

Vector databases (pgvector)

Job description

Blaugarnet is building the Intent Layer for AI-driven software — a layer that sits above the coding tools your team already loves and below business strategy.

AI can now write most of the code. What it can't do on its own is make sure that what gets built is what the business actually intended, or prove who decided what, and why. Our product captures business intent from raw, messy sources, runs it through a governed, human-in-the-loop system that deliberates each decision from multiple expert perspectives, and produces human-authorized blueprints an AI agent can build from correctly, backed by a permanent, append-only record of every decision made along the way.

Our enterprise product is live in early access. We're small, early, and moving fast.

The role

This is a hands-on senior engineering role at the core of the product, not an AI role bolted onto the side of a business. The AI reasoning system is the product, so the systems you build are the product itself.

You'll design and ship the reasoning engine, retrieval pipelines, and the evaluation and guardrail machinery that makes them trustworthy in production. You'll work directly with our Founding Engineer and close to the founders, with a short path from idea to production. You'll also help set the technical bar for the engineers who join after you.

We're looking for someone who has taken AI systems into production and felt the difference between a demo that impresses and a system that holds up, and who wants a scope far larger than a big-company AI team would ever hand them.

What you'll do

Design and build the core LLM reasoning and orchestration engine — planning, tool use, memory, and validation.

Architect enterprise RAG pipelines over structured and unstructured data using vector databases (e.g. pgvector) and embedding pipelines.

Develop AI automation pipelines — workflow engines and decision and data-quality logic that integrate with real business systems.

Build and maintain backend services — Python / FastAPI, async services — powering data-heavy AI applications.

Make AI systems trustworthy in production — LLM evaluation frameworks, guardrails, and benchmarks for reliability and safety.

Own cost and performance — token/cost tracking, budget enforcement, and model-selection heuristics.

Build MCP-compatible tools and integrations across providers (OpenAI, Anthropic, Gemini).

Own CI/CD and containerised deployment of AI services (Docker, GitHub Actions).

Raise the bar around you — code review, technical deep-dives, mentoring, and contributions to internal and open-source AI tooling.

Stay close to the problem — engage with real customer context and feedback; help shape what we build, not just how.

What you'll bring (required)

4-6 years of software engineering overall, with strong backend skills in a modern typed/async stack (we use Python/FastAPI today).

AI-native development as your default mode — you work with coding agents (Claude Code, Cursor, or similar) daily to design, build, and verify production systems.

2-3 years hands-on building AI/GenAI systems in production — real users, real failure modes.

Deterministic orchestration of LLM workflows — control flow and guardrails built into engineered machinery (state-machine / workflow-engine style), not left to the model's discretion; strong context engineering within that structure.

Guardrails enforced outside the model — deterministic checks on non-deterministic output, so the rules hold even when the model doesn't. (We build a governed system, not autonomous agents.)

RAG in production — vector databases, embedding pipelines, retrieval over messy real-world data.

Relational data modeling under correctness constraints — append-only / immutable records, provenance and lineage integrity, sequence and transactional correctness. Strong SQL / Postgres; you build a system of record, not a cache.

LLM API integration across providers (OpenAI, Gemini, Anthropic), including multimodal pipelines (text, vision, structured data).

Async programming and solid API design.

Docker, Git, and CI/CD workflows (e.g. GitHub Actions).

Evaluation-harness design — because output is non-deterministic and quality is subjective, you've built the eval sets, benchmarks, and regression checks that keep quality from silently drifting when models or prompts change.

Judgment about cost and performance — prompt engineering, token/cost tracking, and model-selection trade-offs.

Startup temperament — high agency, comfort with ambiguity and shifting priorities, a bias to ship, and direct, low-ego communication. You're comfortable owning a problem end to end without a fully specified ticket.

Nice to have

Open-source contributions to the AI ecosystem (LangChain, vector DB integrations, etc.).

Published technical writing, PyPI packages, or public speaking on LLMs, RAG, or agents.

MCP (Model Context Protocol) tooling and agent-interoperability standards.

Comfort driving coding agents (Claude / Cursor) to build and integrate a standard React / TypeScript frontend against your API contracts.

Experience in regulated or high-stakes enterprise domains (governance, audit, compliance).

Early-stage startup experience.

The AI is the product. Your systems are the product itself, not an internal tool or a feature on someone else's roadmap.

Scope you won't get elsewhere. Early team, real ownership, and a direct line to the founders.

Live product, real stakes. A live enterprise product in early access — what you ship is the product, not a demo.

Learn from a founder who has built at the top. 25 years of AI and product at Google and Adobe, working with you directly.

Grounded, not hype-driven. Customer-focused and deliberate; we hire carefully and invest in the people we bring on for the long run.

Build the team you'll work in — you're early enough to shape the engineering culture, not inherit it.

Compensation & Logistics

Location: Pune, India — hybrid.