AI Engineer

What matters most

• Ship governed agent workflows

  The role owns insurance workflows from tool contracts and capability boundaries through approval gates, review, deployment, and production. Prepare to explain how human judgment remains in control and how authorization and safety properties are enforced in code.

• Preserve workflow state across failures

  Vouch uses pinned worker versions and a CI replay-compatibility gate so crashed workers can resume mid-workflow. Prepare to discuss durable execution, state recovery, and how changes are checked against in-flight work.

• Make model behavior testable

  Deterministic corpus tests gate merges; evaluation suites diagnose behavior; characterization corpora protect refactors. Prompts and tool definitions are versioned and snapshot-tested, with tracing and token/cost observability.

• Connect agents to systems of record

  The engineer runs two-way plumbing involving schema-governed domain events, object storage, and OLTP/OLAP databases. Prepare to discuss data contracts and how agent actions remain traceable to authoritative records.

• Own traceable production changes

  The posting emphasizes small increments, design documents, substantive review for silent failures, and fixing production issues. Written tradeoffs and follow-through matter alongside implementation.

Likely challenges to think through

• Balance experimentation with consequential decisions

  Likely preparation hypothesis: rapid LLM prototyping may conflict with the controls needed for judgment-heavy insurance work. Prepare an example of testing a proposed capability with evaluations while keeping approvals and authorization outside the model's discretion.

• Evolve code without breaking in-flight workflows

  Likely preparation hypothesis: changing workers, tools, or event schemas could threaten replay or downstream compatibility. Prepare to reason through versioning, compatibility tests, and recovery after an interruption.

• Detect failures that passing tests miss

  Likely preparation hypothesis: deterministic merge gates cannot cover every model behavior or delayed downstream error. Prepare to explain how characterization tests, tracing, and review could expose misleading outputs or silent data failures before and after release.

Topics to prepare

• Agent authority and human approval

  The role designs tool contracts, capability boundaries, and approval gates for insurance work under human judgment. Suggested revision exercise: diagram an agent action that reads a record, proposes a change, and waits for approval; mark where authorization and safety checks must be enforced in code rather than prompts.

• Durable execution and replay compatibility

  The posting describes pinned worker versioning and a CI replay-compatibility gate so crashed workers can resume without losing state. Suggested revision exercise: trace a workflow through a crash and a worker update, then identify which state and versioning assumptions make replay safe.

• Evidence for model behavior

  Deterministic corpus tests gate merges, while evaluation suites diagnose behavior and characterization corpora pin behavior before refactors. Suggested revision exercise: classify example failures by which test or evaluation would detect them, and explain what each result would and would not establish.

• Event and data boundaries

  The role connects agents to systems of record through schema-governed domain events, object storage, and OLTP/OLAP databases. Suggested revision exercise: sketch how an approved agent action becomes a domain event and reaches a system of record; identify schema and authorization boundaries.

• Production reliability and written reasoning

  The posting emphasizes API design, data contracts, observability, traceable changes, design documents, and reviews that catch silent failures. Suggested revision exercise: outline the tradeoffs in a small API change and list failure cases, including a valid-looking empty value that causes a later-stage error.

Skills to revise

• Implement a bounded tool call

  Hands-on LLM agent experience and fluency in a strictly typed codebase are stated requirements; MCP, the Anthropic SDK, or equivalents are named examples. Suggested practice: implement a typed tool contract for a hypothetical insurance-record lookup, with input validation, an authorization check, and a human-approval gate before any write.

• Test workflow recovery

  The role extends a durable-execution system with pinned worker versions and a replay-compatibility gate. Suggested practice: write a small workflow test that interrupts execution after a completed step, resumes it without repeating that step, and checks replay after a code change.

• Build a model-behavior regression check

  The posting calls for deterministic corpus tests, diagnostic evaluations, characterization corpora, and versioned, snapshot-tested prompts and tool definitions. Suggested practice: create a small fixed set of tool-call cases, record expected outcomes, and review a prompt or tool-definition change against those outcomes.

• Trace an agent action end to end

  LLM tracing and token/cost observability are part of the role. Suggested practice: instrument a sample agent request so its tool calls, approval decision, outcome, and token/cost totals can be inspected together; check whether a silent failure would be visible.

• Review a schema-governed event change

  The role works with schema-governed events and data stores; schema registries and Avro/Protobuf are listed as nice-to-haves. Suggested practice: draft a domain-event schema change, examine how existing consumers would handle it, and write a short review note covering compatibility, data contracts, and failure paths.

• Build a role-evidence map

  Prepare a one-page map of the posting’s table-stakes—real-user LLM agents, strictly typed code, production-service fundamentals, safety in code, written tradeoffs, and early-stage or high-growth work—to specific examples you can discuss. Mark any gaps rather than inventing examples.

• Rehearse an end-to-end agent walkthrough

  Choose a real project, if available, and explain its tool calls, contracts, authorization boundaries, human approval points, deployment, and production ownership. Use a diagram to distinguish enforced safeguards from prompt instructions.

• Sketch a durable-workflow design

  As a preparation exercise, draw how an interrupted worker could resume without losing state. Address pinned worker versions, replay compatibility in CI, and failure cases; label your design choices as proposals, not Vouch’s implementation.

• Prepare an evaluation artifact

  Draft a sample test plan separating deterministic corpus merge gates from diagnostic evals and characterization tests. Show how you would version and snapshot-test prompts and tool definitions, and inspect traces and token costs.

• Diagram the system-of-record boundary

  Sketch a proposed flow between an agent, schema-governed events, object storage, and OLTP/OLAP data. Annotate data contracts, access checks, and where a silent failure might be detected.

• Practice a written technical review

  Write a short design note or review comment that identifies a subtle failure path, weighs alternatives, and proposes a test or code-level safeguard. Be ready to explain how you verify coding-agent output and handle a production correction.

• Bring focused questions for Vouch

  Prepare questions about how experts approve agent actions, how replay and corpus gates shape releases, and how engineers investigate failures. The page describes a case study or technical screen and hybrid attendance Tuesday through Thursday; confirm relevant logistics with the team.