Lead AI Engineer

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. 

• 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