Systems · Open role
Own the AI operating layer Lucentive runs on.
You own the shared AI operating layer: the orchestration that composes tools, memory, and retrieval into a runtime, the provider abstraction that survives a migration, and the evals that stay reliable as more products depend on the layer.
Mission
What the role does and why it matters here.
The Senior AI Systems Engineer owns the AI operating layer shared across Lucentive, not one engagement's extraction pipeline. That means the orchestration that composes tools, memory, and retrieval into a runtime; the model-provider abstraction that lets a mixed-model strategy survive a provider migration; and the eval suite that has to stay reliable as more products pull the same layer in, not just the one it was built for. Where an engagement-level AI Engineer builds the pipeline for a client, you design the pattern they build it from and keep it coherent as it scales past the first consumer. You work alongside the Context Architect, translating a validator spec into the orchestration layer's contract, and alongside product and delivery engineers who build on top of what you own. Most weeks the artifact is the abstraction itself: the interface, the eval, the migration path, written so the next team that adopts it does not have to ask you first.
Responsibilities
What you would own.
Design and own the agent orchestration layer: how tools, memory, retrieval, and multi-step reasoning compose into a runtime other products build on.
Build the model-provider abstraction used across Lucentive's products, so a provider swap or a mixed-model strategy does not force a rewrite at the call site.
Own the eval suite used across products: truth sets, regression coverage, and drift detection that catches a build before it ships, not after.
Set the pattern other engineers implement per engagement, and judge when a client-specific pipeline should graduate into a shared one.
Review the agentic architecture decisions made across engagements and keep them coherent as they scale into one operating layer.
Maintain production observability for agent runs across products: what ran, on what model, at what tradeoff, without leaking harness internals into user-facing UI.
Partner with the Context Architect to turn a validator spec into the orchestration layer's contract.
How you think and work
Six traits the work demands.
Pedigree isn't the filter. Disposition is. The six traits below are what the work actually asks of you.
Agentic intuition
You read agents the way a manager reads a direct report: when to trust the output, when to interrupt the run, when to take the wheel back.
You design orchestration knowing which failure mode an agent hits at step four, not just step one, and you build the intervention point before it's needed.
Critical thinking
Confident-sounding output gets the same scrutiny as anything else, your own work included.
You've killed an eval that was green for the wrong reason and replaced it with one that actually tests the failure you cared about.
Curiosity
You pull on threads. You read outside the lane. You follow a question past the first plausible answer.
You read a model provider's changelog the day it ships, because the orchestration layer's assumptions might just have changed.
Agency
You move without being told. You decide, ship, own the call. No one has to write the playbook for you.
You've built the shared abstraction nobody asked for yet, because the second engagement was going to need it.
Systems thinking, long view
You see how the parts connect, and where this goes in three years.
You design the provider interface for the migration you haven't been asked to do yet.
Leadership instinct
You orchestrate work across humans, agents, and stakeholders. You switch register between a workspace ticket, an architect call, and a senior bank room in the same day without losing what you came in to say.
You've set the pattern other engineers build against, and defended it in review without turning it into a standoff.
Useful background
- Senior experience building agentic systems in production: multi-step agent runtimes, tool use, and retrieval, not a single prompt-and-response integration.
- Hands-on model orchestration across more than one model provider, with a real migration or multi-provider strategy behind you.
- You've built or owned an eval suite that caught a regression before it shipped, not one that passes vacuously.
- Comfortable owning infrastructure that multiple products or teams depend on, where a design decision has to work beyond its first consumer.
- Typed, production-grade engineering discipline (a stack like Next.js and Convex, or equivalent) so you can ship the orchestration layer, not just diagram it.
- You've designed an abstraction that outlived the first framework or provider it was built for.
- You've worked at the boundary between an AI system and a regulated or high-stakes domain, where "the model said so" was never sufficient evidence.
- You've set technical direction for other engineers building on top of infrastructure you own.
- Your evals and prompts live in version control with diffs and review, and you've made the case for why that discipline matters.
Regulated-industry experience isn't required. Curiosity about it is.
Logistics
How the role is set up.
- Location
- Remote. EU-based team, with at least four hours of overlap with CET on a working day; Portugal hub.
- Engagement
- Contract or full-time.
- Start
- Flexible, coordinated at offer stage.
- Language
- English, the working language for engineering and review.