AI Engineer

Hilbert; United States; Remote; USD 140,000 - 190,000; Full time

Job summary

Hilbert is building a reasoning engine to navigate non-deterministic user behavior across data silos. We seek an AI Engineer to own core AI stack pieces, from prototype to pipeline to product, with startup urgency and ownership.

You will design agent architectures, build evaluation systems, and balance accuracy, latency, and cost in production. Expect fast shipping amid evolving specs and clear internal communication.

Qualifications

• 4+ years of production software engineering (APIs, services, data infra) ownership and on-call.
• 2+ years building LLM or agent systems deployed to production.

Responsibilities

• Own the evaluation layer for agents: harnesses, metrics, regression gates, and human-in-the-loop review.
• Architect and implement agent workflows using LangChain, LangGraph, or equivalents with memory, routing, registries, and recovery paths.
• Own systems from experimentation through production: tracing, monitoring, latency, and cost-per-task budgeting.

Skills

Production software eng

LLM/agent systems

LangChain

LangGraph

Backend APIs

Tools

LangChain

LangGraph

OpenTelemetry

Job description

About Hilbert

Hilbert is a scalable, data science-first growth engine that gives B2C teams predictive clarity into user behavior, revenue drivers, and the actions that drive sustainable growth. Fully agentic by design, Hilbert shrinks months-long decision cycles to minutes.

From Fortune 10 enterprises to beloved brands like FreshDirect, Blank Street, and Levain Bakery, operators run their growth on Hilbert. We’re also co-building alongside leading AI companies.

Position Overview

Hilbert is building a reasoning engine that must navigate non-deterministic user behavior across data silos. Our demand intelligence platform doesn’t just call APIs. It solves the hard problem of orchestrating multi-step inference over messy, high-stakes enterprise data where deterministic answers don’t exist.

We’re looking for an AI Engineer who can build production‑grade AI systems end‑to‑end, from prototype to pipeline to product, with the ownership and urgency of a startup culture.

This is not a “wire up a prompt chain and move on” role. You’ll own core pieces of the AI stack that power Hilbert’s platform: designing agent architectures, building evaluation systems, and making hard tradeoffs between accuracy, latency, and cost in production. You’ll ship fast while the spec is still evolving, and you’ll explain what you’re building (and why) clearly to the rest of the team. If you think in systems, have opinions about how agentic workflows should actually work, and want to build AI products that drive real enterprise outcomes, we want to meet you.

What you’ll own first: evaluation and testing for our agents

Hilbert’s agents are in production with enterprise customers today. Before we expand what they do, we need to know, reproducibly, when a change makes them better or worse. You’ll design the eval harness, define what “correct” means for a multi-step agent trajectory, build the regression gates that run before anything ships, and turn production failures into test cases. From there, your scope widens to retrieval, orchestration, and execution across the AI stack.

What you’ll do

• Own the evaluation layer for our agents: harnesses, metrics, golden datasets, regression gates, and human-in-the-loop review.
• Architect and implement agent workflows using LangChain, LangGraph, or equivalent, including state memory, routing, tool registries, and recovery paths.
• Own systems from experimentation through production, and operate them once they’re live: tracing, monitoring, latency, cost-per-task budgeting, and on-call for what you build.
• Diagnose real production failures (hallucination, tool misuse, retrieval misses, silent degradation) and turn each one into a durable fix and a test.
• Set the technical standard for agent work at Hilbert: review designs, define patterns others build on, and raise the bar across the team.
• Collaborate closely with the founding team and cross-functional partners, communicating tradeoffs, progress, and technical decisions clearly.
• Make pragmatic engineering decisions under ambiguity: ship, learn, iterate.

Our current hurdles: the kinds of problems you’ll walk into on day one

• Intelligent retrieval across different approaches. Our agents need the right information at exactly the right moment. The challenge isn’t picking one retrieval method. It’s combining RAG, graph‑based retrieval, and other approaches into one strategy that fetches the most relevant content exactly when the agent needs it, no more and no less.
• Agentic workflows that solve real‑world problems. Workflows have to be robust enough to handle the unexpected. When an agent hits an edge case, missing data, or a situation it wasn’t designed for, it needs to reason through it: use the context it has, elevate to a human when it can’t, and never fail silently.
• Evaluation beyond vibes. We need systematic, reproducible evals that actually predict real-world performance. If you’ve built custom evaluators for RAG or agent workflows, we want to talk.
• Execution and real‑world integration. An agent that only surfaces insights isn’t enough. We’re building systems where agents take action: integrating with external platforms, executing workflows, and doing real work with the information they have, with human‑in‑the‑loop checkpoints that keep enterprise trust intact.

Who thrives in the role

We care about what you’ve shipped and how you think. We expect 4+ years of building production software, with at least 2 of those on LLM or agentic systems that real users depend on.

Must-haves:

• 4+ years of production software engineering (APIs, services, data infrastructure). You’ve owned code other people depended on, with tests, CI/CD, and on-call attached.
• 2+ years building LLM or agent systems that shipped to production and were adopted by real users. Not internal demos, not prototypes. Be ready to talk about what broke in production and what you did about it.
• Hands‑on experience with LangChain, LangGraph, or equivalent agent/orchestration frameworks. You’ve built with them, hit their limits, and worked around them. You go well beyond following tutorials.
• Clear, confident communication. You can explain a technical decision to a non‑technical founder and debate architecture tradeoffs with a senior engineer. Communication isn’t a nice‑to‑have here; it’s core to the role.
• Ownership. You don’t wait for tickets. You see what needs to be built, raise your hand, and ship it.
• Comfort with ambiguity. AI products evolve fast and requirements change. You’re energized by figuring it out.
• Startup speed. You move without waiting for permission, and you know which decisions deserve a day of thought and which deserve an hour.

Strong pluses:

• Deep experience with retrieval‑augmented generation (RAG): hybrid and graph retrieval, chunking and embedding strategy, ranking, grounding.
• Observability for LLM systems (Langfuse, OpenTelemetry, or equivalent) and cost/latency optimization.
• MCP, tool‑calling frameworks, structured output, and constrained decoding.
• Experience at early‑stage startups or high‑growth environments where you wore multiple hats.

You might be:

A backend engineer who went deep on LLMs and never looked back. An ML engineer who realized they love building products, not just models. A startup CTO who wants to go deep on AI at a company where the stack is the product. Someone who’s been hacking on agents and pipelines on nights and weekends and wants to do it full‑time with real enterprise stakes. What matters: you ship, you own it, and you communicate like a teammate, not a silo.