Senior AI Engineer

Chubb; Toronto; On-site; CAD 150,000 - 190,000; Full time

Job summary

Chubb AI builds an enterprise AI platform and seeks an engineer to design and implement the core agent infrastructure, including orchestration engines, desktop harness, tool registries, and policy layers. You will work with frontier SDKs and agent loops, owning model-agnostic routing and grounding components while ensuring safe, scalable operations.

The role emphasizes hands-on development, architecture ownership, and collaboration with platform engineering, DevOps, security, and Model Risk

Qualifications

• 7+ years building production software with recent work on LLM-based systems.
• Strong TypeScript and Python (FastAPI, async, Pydantic).
• Production depth in Microsoft Agent Framework, LangGraph or Deep Agents.
• Direct experience with frontier provider SDK at the agent-loop level.
• Hands-on with tool calling, MCP or similar protocol, streaming (SSE/WebSocket), and structured output.
• Cloud-native delivery: containers, Kubernetes (AKS preferred), CI/CD, and observability.
• Ability to work through ambiguity with stakeholders.

Responsibilities

• Design and build core agent infrastructure: orchestration engines, desktop harness, and policy layers.
• Develop integration with frontier SDKs (Claude, OpenAI, Gemini) and agent SDKs.
• Own model-agnostic routing, cost accounting, and degradation strategies.
• Create tool registries, skill systems, and versioned artifacts for capabilities.
• Build retrieval, grounding, vector search, and citation pipelines.
• Develop offline eval, regression gates, and diagnosable failure tracing.
• Implement multi-runtime harness behind a single API and event stream.
• Create adapter layers for SDKs, events, and permission semantics; support runner/server split.
• Integrate MCP: stdio and remote SSE servers, and UI bridge for sandboxed widgets.
• Implement permission system (ALLOW/ASK/DENY) driven by policy hooks.
• Work on sandboxing: tokens, namespaces, Seatbelt/Bubblewrap, and container options.
• Schedule memory and continuity features: recurring tasks, cross-conversation references, indexing.
• Apply patterns: facade, adapters, factories, DI, registries.
• Maintain clear separation between business logic and infrastructure, with strong error handling.
• Ensure observability with logging, tracing, and memory-growth monitoring.
• Design multi-tenant architectures with entitlements and OAuth delegation.
• Write design docs.

Skills

LLM systems

TypeScript

Python

Microsoft Agent Framework

LangGraph

Deep Agents

Tool calling

MCP protocol

Streaming (SSE/WebSocket)

CI/CD

Observability

Cloud-native

Tools

FastAPI

Pydantic

Kubernetes

AKS

WebSocket

Job description

Chubb AI builds the enterprise AI platform for Chubb. The platform is a multi-tenant, model-agnostic environment that spans a web application, a desktop agent client, an AI App Store, a skills and extension ecosystem, and an API/tool layer over Chubb's knowledge.

The role

Design and build the agent infrastructure at the core of the platform: orchestration engines, the desktop agent harness, the skills and tool registries, and the policy layers that make it safe to run inside Chubb. This is a hands-on engineering role with architectural ownership, working closely with platform engineering, DevOps, security, and Model Risk Governance.

What you’ll work on

• Build and extend multi-agent orchestration on Microsoft Agent Framework, LangGraph, and Deep Agents, including stateful graphs, checkpointing, sub-agents, human-in-the-loop interrupts, and long-running or background execution.
• Build directly against frontier LLM SDKs and agent layers: Anthropic’s Claude SDK and Agent SDK, OpenAI’s Agents SDK and Responses API, and Google’s Gemini/GenAI SDK.
• Own the model-agnostic layer: routing across providers, adaptive routing logic, extended-thinking support, cost and token accounting, and graceful degradation as models and SDKs change.
• Design agent capability surfaces: tool registries, agent registries, a lazy-loading skill system, and versioned skill promotion through immutable artifacts.
• Build retrieval and grounding: document parsing, metadata-first ingestion, vector search, and end-to-end citation pipelines for documents and web results.
• Build evaluation infrastructure: offline eval suites, regression gates on prompt and model changes, and tracing for diagnosable agent failures.
• Engineer a meta-harness that runs multiple underlying agent runtimes behind one uniform API and event stream.
• Build adapter layers for harnesses, normalize SDKs/event models/tool schemas/hook systems/session and permission semantics, and support a runner/server split over WebSocket.
• Build MCP integration depth, including stdio and remote SSE servers, first-party servers such as Outlook and Atlassian, and a tool/UI bridge for sandboxed extension widgets with a manifest and permission model.
• Implement the permission system with stateful ALLOW / ASK / DENY decisions driven by policy through hooks.
• Work on sandboxing and process isolation, including restricted tokens, namespaces, Seatbelt/Bubblewrap-class mechanisms, container and microVM options, filesystem policy design, per-session ACLs, and platform-specific drivers.
• Build scheduling, memory, and continuity features such as recurring tasks, cross-conversation reference, file indexing and mentions, and a runtime-agnostic persistent memory contract.
• Apply structural patterns deliberately: facade, adapters, ports-and-adapters, factories, dependency injection, and registries.
• Keep clean separation between business logic and infrastructure; maintain type safety, error handling, idempotency, and environment-agnostic configuration.
• Build for operability with structured logging, OpenTelemetry tracing, Azure Application Insights, meaningful SLOs, and instrumentation for SSE streaming failures and memory-growth patterns.
• Design multi-tenant systems with hierarchical entitlements and role models, per-user OAuth delegation (MSAL/PKCE), and rate and quota enforcement.
• Write the design docs.

What we’re looking for

• 7+ years building production software, with recent, substantial work on LLM-based systems.
• Strong TypeScript and working proficiency in Python (FastAPI, async, Pydantic).
• Demonstrated production depth in Microsoft Agent Framework, LangGraph, or Deep Agents.
• Direct experience with at least one frontier provider, SDK, at the agent-loop level.
• Hands-on experience with tool calling, MCP or a comparable tool protocol, streaming (SSE/WebSocket), and structured output.
• Cloud-native delivery: containers, Kubernetes (AKS preferred), CI/CD, and production observability.
• Ability to work through ambiguity with stakeholders and turn a vague capability ask into a defensible technical design.

Good to have

• Google ADK, Mastra, Pydantic AI, Semantic Kernel, CrewAI, LlamaIndex, AutoGen.
• Other frontier LLM SDKs and agent layers as they emerge, including open-weight and non-US providers.
• LiteLLM or comparable multi-provider gateways and routers.
• Building on or extending Pi Coding Agent, Claude Code, OpenCode, Kimi Code, Codex or similar, especially embedded via SDK.
• Sandboxing and process isolation: OS security primitives, gVisor, nsjail, Firecracker, Seatbelt, Bubblewrap, or similar.
• Desktop application engineering, retrieval systems, vector indexing, citation-grade grounding, eval and LLM observability tooling, React, Nx monorepos, PostgreSQL/Cosmos DB, Redis, regulated environment experience, and insurance or financial services domain exposure.

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.
• You give and take direct technical feedback well.
• You care that the thing works for the person using it.

What we offer in the team

• Ownership of platform foundations used across a global organization.
• A team that treats architecture as a first-class activity.
• Access to frontier models and tooling, and a mandate to figure out what they’re good for.

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.