Lead AI Engineer in Bengaluru, Karnātaka at Kobie Marketing
Explore Related Opportunities
Job Description
About The Team And What We'll Build Together
Kobie runs some of the largest loyalty programs in the world. We're building an internal agent platform on Amazon AgentCore that automates analyst workflows, surfaces insights from program data in Snowflake, and gives our teams an LLM-native way to work with complex loyalty logic.
We're looking for a hands-on Lead AI Engineer to ship the hardest implementation work on that platform. You'll author the per-feature implementation specs that turn architectural decisions into work the team and our code agents can build against. You'll also build the load-bearing pieces yourself — the human-in-the-loop routing primitive, the reversibility-tier execution wrapper, the guardrails that make agent actions safe to deploy — and review PRs at a depth that lifts the standard for what we ship.
Our team tends to be people who reason carefully, ship working code, and pick up new tools without a lot of hand-holding. We care less about the shape of your career than whether you've built things that held up.
How We Think About AI
We're building agents for an industry — loyalty marketing — that runs on judgment. The analysts and strategists we serve know things that don't live in any database: which clients can hear which feedback, when a campaign is technically sound but commercially wrong, what a number means versus what it shows. Our agents make their judgment go further; they don't replace it.
That means we have strong views on where agents should and shouldn't act. As Lead, you turn those views into running code: which tools route to a human for approval, which run autonomously, what the refusal policies actually refuse. We're looking for someone with a considered view on cognitive offloading, the long-term effects of agent-mediated work on organizational capacity, and the discipline to build implementation safeguards that augment human judgment rather than supplant it.
Spec Authoring & Hard Implementation
Author per-feature implementation specs (problem framing, approach, module/file map, contracts touched, test plans) at a rigor level code agents and engineers can build against without re-deriving design intent
Ship the hardest implementation work yourself — the human-in-the-loop routing, the public/private gateway access controls, the early agent harnesses
Bring strong design agency: name the implementation tradeoffs, surface gaps in upstream architectural specs, push back when an approach won't hold up in production
Oversight & Reliability
Design and implement the human-in-the-loop routing system: queue mechanics, reviewer assignment, back-pressure handling, run resumption semantics
Implement the execution wrapper that enforces human-in-the-loop polices at execution time
Build the safeguards — refusal policies, prompt-injection protections, public/private MCP exposure controls — that make our agents safe to deploy at scale
Mentorship & Review
Review PRs (human- and code-agent-authored) at a depth that builds shared judgment about what good agent code looks like
Mentor engineers through hard implementation problems; close gaps in the team's shared knowledge
Set the standard for what we ship — and what we refuse to ship
In Your First 90 Days
By the end of your first 90 days, you'll have authored at least two per-feature implementation specs, shipped one load-bearing piece of the platform end-to-end yourself (likely the HITL routing or the execution wrapper), and reviewed enough PRs to have a clear point of view on where our cloud-agent dispatch model is producing good code and where it isn't.
6+ years of professional Python with deep production experience operating services, not just shipping them
2+ years operating LLM systems in production: prompt/context engineering, tool/function calling, structured outputs, RAG, evaluation, observability
Demonstrated experience implementing oversight mechanisms — human-in-the-loop routing, refusal policies, autonomy boundaries — in systems where the cost of an agent error is real
Strong written communication: you'll be authoring implementation specs that other engineers (and code agents) build against, and the spec is the work
Extensive knowledge of LangChain/LangGraph — or a comparable framework like AgentCore Strands, CrewAI, or Semantic Kernel — and a clear view of when to use which
Experience with LLM observability tools: Amazon CloudWatch, LangSmith, Langfuse, MLflow, or OpenTelemetry
Experience designing evaluation frameworks (RAGAS, DeepEval, LLM-as-judge, multi-turn regression)
Solid SQL, fluency with at least one cloud platform (AWS preferred), Git, Docker, and modern API frameworks
A hands-on disposition — you want to ship the hard parts yourself, not just write specs about them
Experience reviewing code authored by junior engineers, contractors, or AI agents — and giving feedback that produces better code next time
A considered view on the failure modes of overusing AI — cognitive offloading, organizational skill loss, agent-mediated drift in decision-making — and the conviction to design against them
A bachelor's degree is not required. Equivalent practical experience — including bootcamps, self-taught work, career changes, or non-CS technical degrees — counts.
Nice To Have
Hands-on experience with Amazon Bedrock and/or AgentCore as a developer: runtime, gateways, memory, policy, guardrails, observability, evaluations, optimizations
Experience with Snowflake, Snowpark, or Snowflake Cortex
Experience in loyalty, martech, adtech, or a comparable data-rich B2B domain