Senior AI Engineer - Forward Deployed (FDE)

The Role

We're hiring a Senior AI Engineer who took an unusual path — and we want that path specifically. You've spent 8–12 years as a serious software engineer, much of it building cloud-native systems and platforms on AWS. And in the last year, you've gone deep into AI: building agents, RAG systems, and LLM-powered applications — not reading about them, building them.

We're not looking for ten years of GenAI experience. Nobody has that. We're looking for deep engineering fundamentals with recent, real AI depth on top — because the hardest problems in AI right now are engineering problems: reliability, cost, latency, security, and evaluation of non-deterministic systems. That's your home turf.

You'll work across both sides of our stack: shipping AI capabilities in the product, and building the platform primitives underneath them — model access, agent orchestration, retrieval, and evaluation. You'll own systems end to end, make the architecture calls in your area, and raise the bar for the engineers around you. Senior IC role — lead by building, not by managing.

This is also a forward-deployed role. We build with our enterprise customers, not just for them — so you'll spend real time embedded with client teams: inside their systems, their security constraints, and their conference rooms, making our AI work in their world. Then you'll bring what the field taught you back into the product, so the next deployment is faster than the last.

What You'll Do

Build AI capabilities.

•  Design, build, and ship agents, agentic workflows, and LLM-powered features — from prototype to production, end to end.

•  Build retrieval that actually works: chunking and embedding strategies, vector search, hybrid search and re-ranking, and honest measurement of retrieval quality.

•  Integrate models and tools cleanly: Anthropic, OpenAI, and Bedrock model APIs; tool and data access via the Model Context Protocol (MCP), with its security considerations handled, not hand-waved.

Deploy with our enterprise customers.

•  Embed with client teams: run technical discovery, map their workflows and systems, and shape the AI solution that fits their environment — then build and ship it yourself.

•  Integrate with the systems enterprises actually run: identity and SSO (SAML/OIDC, Okta, Active Directory), enterprise APIs, data warehouses and legacy databases, and systems of record like Salesforce, ServiceNow, or SAP.

•  Deploy into customer environments — their AWS accounts, private VPCs, restricted networks — and design for their security model, not just ours.

•  Be the technical face of the company on the ground: run working sessions and demos with client engineers and business stakeholders, and navigate enterprise InfoSec and architecture reviews with credibility.

•  Close the loop: turn field learnings — integration patterns, platform gaps, recurring requests — into product and platform improvements.

Build the platform underneath.

•  Build our model-access layer: unified interface across providers, routing on cost/latency/capability, caching, rate limits, and cost tracking per feature.

•  Build agent orchestration and lifecycle plumbing — state and memory, retries, guardrails, versioning, and rollback — on frameworks like LangGraph or CrewAI where they help, custom where they don't.

•  Stand up the evaluation harness: automated evals and regression tests wired into CI/CD so AI changes ship with evidence, not vibes.

•  Instrument everything: tracing of agent reasoning and tool calls, cost and latency dashboards, quality monitoring.

Own the infrastructure.

•  Own AWS infrastructure for AI workloads — EKS/ECS, Lambda, IAM, networking, infrastructure-as-code — built for security and scale from day one.

•  Operate what you build: production ownership, on-call sanity, and performance/cost tuning as usage grows.

Lead by building.

•  Drive design reviews and set the technical patterns others follow — you make the architecture calls in your area and can defend the trade-offs.

•  Mentor 1–2 engineers and level up the team's AI engineering practices.

•  Make pragmatic build-vs-buy calls in a fast-moving ecosystem without chasing every shiny framework.

Requirements

What We're Looking For

•  8–12 years of software engineering experience, with significant time building cloud-native systems, backend services, or platforms — platform engineering background strongly preferred.

•  Deep, hands-on AWS expertise: EKS/ECS, Lambda and serverless patterns, IAM and networking, and infrastructure-as-code (Terraform or CDK). You've operated real production services with real SLOs.

•  Strong Python and the habits of a production engineer: testing, code review, observability, and clean design under deadline pressure.

•  Solid grounding in distributed systems, API design, and event-driven architecture.

•  Recent, demonstrable AI depth — within roughly the last year is fine; we care that it's real. You've built agents, RAG pipelines, or LLM applications hands-on and can walk us through what you built, what broke, and what you'd do differently. Production work, serious side projects, and open source all count.

•  Working experience with at least one agent framework (LangGraph, CrewAI, or comparable) and the major model APIs (Anthropic, OpenAI, Bedrock).

•  Practical understanding of LLM behavior: context management, token economics, cost/latency trade-offs, and why non-determinism changes how you test and ship.

•  Good understanding of RAG with a focus on retrieval — and of how to measure whether it's actually working.

•  Familiarity with MCP, including its current limitations and security considerations.

•  Experience integrating with enterprise systems — identity/SSO (SAML/OIDC), enterprise APIs, data platforms, or systems of record — and working within enterprise security, network, and compliance constraints.

•  Customer-facing engineering skills: you're credible in the room with client architects and business owners, you can run a demo and a discovery session, and you communicate trade-offs in plain language.

Nice to Have

•  Experience building or operating a model/LLM gateway or proxy layer.

•  Model serving experience — vLLM, GPU scheduling, or inference optimization.

•  Guardrails, prompt-injection defense, or LLM security work (OWASP LLM Top 10).

•  TypeScript for product-surface work.

•  Prior startup experience — you've shipped with small teams and moved fast without breaking trust.

•  Prior forward-deployed, solutions engineering, or technical consulting experience with enterprise customers.

•  Experience delivering customer-deployable software — single-tenant, customer-VPC, or on-prem models.

How You Work

•  You own outcomes, not tickets — you'll take a fuzzy problem, shape it, build it, and run it.

•  You're pragmatic about new technology: excited by the ecosystem, skeptical of hype, honest about trade-offs.

•  You ship fast and still sleep at night, because you built in the tests, evals, and observability that let you.

•  You're as effective in a customer's war room as in the codebase — you listen before you build, translate business problems into systems, and earn the trust of senior client stakeholders.

Details

Location:   Atlanta, GA, USA (100% on-site).

Type:   Full-time, senior individual contributor.

Travel:   Up to 30% to customer sites.

Work authorization:   You must be authorized to work in the United States; visa sponsorship is not available for this role at this time.

To apply, send your resume and a short note on an AI agent, application, or system you've built to careers@moring.ai.