OB - Lead AI Engineer

ABOUT EMPIRICAL

Empirical is a new kind of product development partner — people-first at our core, AI-driven by design. We help tech companies build products that people love across four areas: AI-enabled product & tech leadership (advisory, coaching, and fractional models), end-to-end product development (concept to launch), nearshore AI-enabled team augmentation (high-performing Latin American talent that integrates with your workflows), and AI strategy & implementation consulting (finding where AI drives the most value in your product, operations, or customer experience).

We’re a people-first company grounded in empathy, integrity, and meaningful collaboration. From strategic planning to hands-on execution, we work alongside founders and teams to bring great products to life—without the noise.

Our Core Values

• Care about people first

• Strive to add value always

• Lead with integrity

• Have fun every step of the way

THE OPPORTUNITY

We are building a development pipeline for one of our clients where business users initiate work, AI agents implement it, and engineers review outcomes rather than steer execution. You will lead that build and own the machinery that makes it safe enough to run: the conventions, gates, identities, autonomy tiers, and measurements that determine whether AI-generated code is safe to merge.

Most engineering roles are measured on what you ship. This one is measured on what the pipeline ships. If a good week is one where you personally closed a lot of tickets, this role will frustrate you. If a good week is one where forty changes went through cleanly and you spent Thursday deleting a rule that had stopped earning its place, keep reading. The hard part of this job is not building the automation; it is refusing to trust it.

What You’ll Do

• Own the knowledge plane: project conventions, reusable agent procedures, and source indexing so agents find every relevant call site, plus the enforcement that makes it all stick. This is the highest-leverage surface in the system.

• Build gates that read artifacts: verification that inspects what actually happened (did the test file change, does coverage include the new branch) rather than trusting an agent’s account of its own work, including a protected path around tests and CI config.

• Design authority and identity: least-privilege, short-lived agent credentials where an agent’s authority is the intersection of its own and its sponsor’s, never the union, with attribution from every commit back to a person, an agent, and a task.

• Calibrate autonomy tiers: a classifier that routes changes by how hard they are to undo and fails toward caution. Copy changes merge themselves; schema migrations get a plan and a human. You will move the boundaries based on incident history, not optimism.

• Engineer containment: circuit breakers that stop a repair loop from amplifying its own failures, per-workflow ceilings on tokens, wall-clock, retries and concurrency, progressive exposure, and rollback.

• Own intake and measurement: the request surface with real reproduction context attached, deduplication and routing, plus a gate log that records every evaluation (passes included) and an evaluation harness so configuration changes are shown to be improvements, not assumed to be.

• Run the improvement ritual: dated incident records, a threshold before a pattern becomes a rule, and a recurring pass that asks what each rule cost versus what it prevented. Removal is a first-class outcome.

WHO YOU ARE

• Based in Latin America, with enough timezone overlap for daily collaboration with a U.S.-based engineering team.

• 10+ years in software engineering, including deep CI/CD and platform experience: you have built pipelines other engineers depend on, and you have been on the hook when one broke at 6pm on a Friday.

• A genuinely strong engineer first: you cannot govern code you can’t read, and the person setting the standard for agent output has to be bet