Senior AI Systems Engineer in Eu

• 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.

• Remote
• EU-based
• CET overlap
• Contract or full-time
• 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.

• Own the orchestration layer
• 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 provider abstraction
• 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
• 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
• Set the pattern other engineers implement per engagement, and judge when a client-specific pipeline should graduate into a shared one.
• Keep architecture coherent
• Review the agentic architecture decisions made across engagements and keep them coherent as they scale into one operating layer.
• Maintain production observability
• Maintain production observability for agent runs across products: what ran, on what model, at what tradeoff, without leaking harness internals into user-facing UI.
• Turn validator specs into contracts
• 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.

• 01 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.

• 02 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.

• 03 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.

• 04 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.

• 05 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.

• 06 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.

#J-18808-Ljbffr