Senior AI Engineer

Senior AI Engineer

About Chubb

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 at scale. In 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 TypeScript), comprehensive error handling, idempotency, and environment-agnostic configuration.
• Build for operability from day one: structured logging (structlog), OpenTelemetry 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.

Prompt Integration & Guardrails

• 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.

Collaboration

• Plan and track your own work against clear outcomes in agile sprints.
• Partner with product and senior engineers to translate requirements into working AI features.
• Communicate clearly across technical and non-technical audiences.

What You Bring

Required

• 6-8 years building production software, with recent, substantial work on LLM-based systems that real users depend on.
• Deep experience with Python / Go / Rust and similar languages, building safe, scalable, multi-tenant production systems.
• Experience with test-driven development as a design discipline, writing tests first rather than retrofitting them.
• Direct experience with at least one frontier provider SDK (Anthropic, OpenAI, Google) at the agent-loop level, not just chat completions.
• Fluency in software design patterns and the taste to know which problem each one actually solves.
• Cloud-native delivery; containers, Kubernetes (AKS preferred), CI/CD and production observability.
• Solid command of LLM behaviour including prompt engineering, structured outputs, function calling, and context window management.
• Familiarity with REST APIs and cloud AI services including Azure OpenAI, AWS Bedrock, or GCP Vertex AI.
• Ability to work through ambiguity with stakeholders and turn a vague capability ask into a defensible technical design.

Good to have

• Google ADK, Mastra (including declarative YAML workflows), Pydantic AI, Semantic Kernel, CrewAI, LlamaIndex, AutoGen - breadth here is useful, and having formed opinions about where each breaks down is more useful still.
• Experience across Angular, React, Redis, Nx Monorepos, Cosmos DB / SQL Server.
• Retrieval systems, vector indexing, and citation grade grounding.
• Insurance or financial services domain exposure. (underwriting, claims, reinsurance)
• Experience with LLM observability and tracing tools such as LangFuse or equivalent.

How you work

• You design with standard software engineering patterns before you code.
• You research before you commit, and you write down what you found.
• You prefer production-ready over clever, and you can tell the difference.
• You give and take direct technical feedback well.
• You care that the thing works for the person using it, not only that it ran.

What we offer in the team

• Ownership of platform foundations used across a global organization, not a proof of concept that dies in a demo.
• A team that treats architecture as a first-class activity and gives engineers room to make calls.
• Access to frontier models and tooling, and a mandate to figure out what they're actually good for.

Chubb Canada does not use artificial intelligence (AI) tools to assess, screen, or select applicants. At Chubb we are committed to providing equal employment opportunities to all employees and applicants. It is our policy to provide equal employment opportunities to employees and applicants based on job-related qualifications and ability to perform a job. If you require an accommodation during the hiring process or upon hire, please inform Human Resources. If a selected applicant requests accommodation during the recruitment process, Chubb will consult with the applicant in order to provide suitable accommodation that takes into account the applicant’s accessibility needs.