Senior AI Engineer

Chubb is a world leader in insurance. With operations in 54 countries, Chubb provides commercial and personal property and casualty insurance, personal accident and supplemental health insurance, reinsurance and life insurance to a diverse group of clients. The company is distinguished by its extensive product and service offerings, broad distribution capabilities, exceptional financial strength, underwriting excellence, superior claims handling expertise and local operations globally.

About the Team

We are a fast-moving team delivering AI scalability and governance solutions across Chubb's product portfolio. Engineers work across multiple products, own everything they touch from start to finish, and are expected to rise to the challenges their work demands. We build AI-native, move with purpose, and value engineers who bring both hard work and sound judgment to complex problems.

About the Role

We are looking for an AI Engineer who has shipped ML and LLM systems, built quality and observability tooling around them in production, and is ready to go deeper on that problem  this hands-on role, you will take end-to-end ownership of individual services within a larger AI platform, covering the architecture, data layer, business logic, and API surface without splitting responsibility across specialisms.

You will collaborate with peer engineers to define and hold the integration contracts between services as each piece lands. You will develop iteratively alongside a small team, with short feedback loops and a high bar for what ships.

What You Will Do

Application Development

Design and build production-grade LLM-powered services in Python and Go, integrating with cloud AI APIs such as Azure OpenAI or AWS Bedrock.

Take end-to-end ownership of individual services: data model, business logic, and API surface across all layers.

Build with LLMs as naturally as with any other system component, integrating them into full application stacks rather than treating them as black-box API calls.

Define and maintain integration contracts with peer engineers so independently owned services fit together cleanly as the system grows.

Build configuration-driven systems where runtime behaviour is governed by stored configuration rather than code changes.

Design and implement event-driven, state-based workflows: configurable lifecycle states, transition logic, and trigger mechanisms as production services.

Contribute to containerised deployments using Docker and Kubernetes, following established CI/CD pipelines.

Observability & Evaluation

Build and own evaluation harnesses: golden datasets, rubric-based scoring pipelines, regression suites, and experiment comparison frameworks.

Instrument LLM call paths end to end including distributed tracing, latency, token usage, and model behaviour at scale.

Design recording and data layers that connect live LLM calls to offline quality measurement, making the prompt version, model, and configuration active at decision time fully reproducible.

Surface observability signals in dashboards that are actionable for engineers and legible to non-technical stakeholders.

Software engineering and design patterns

Keep clean separation between business logic and infrastructure; keep abstractions honest and remove them when they stop paying for themselves.

Hold a high bar on type safety (Pydantic, typed Type Script), comprehensive error handling, idempotency, and environment-agnostic configuration.

Build for operability from day one: structured logging (structlog), Open Telemetry tracing, Azure Application Insights, meaningful SLOs, and the instrumentation needed to chase down problems like SSE streaming failures behind ingress or memory-growth patterns under sustained load.

Design multi-tenant systems with real access control: hierarchical entitlements and role models, per-user OAuth delegation (MSAL/PKCE), and rate and quota enforcement.

Write the design docs. Architecture decisions here get reviewed, argued about, and referenced later.

Implement and iterate on prompt templates using established patterns including few-shot, chain-of-thought, structured outputs, and function calling.

Work with versioned content and configuration as inputs alongside prompts: what a model receives at runtime is often composed from multiple managed sources, not a single template.

Manage context windows deliberately through chunking strategy, token optimisation, and retrieval design.

Plan and track your own work against clear outcomes in agile sprints.

Partner with…