About Idun
Idun Group is an independent AI consultancy. We measure how AI is actually used inside our clients, from the logs their platforms already produce, then help them industrialise what works. More than 40 AI assessments in a year; our references include LVMH and L'Oréal. It is tooled consulting: our software, Idun Cockpit, measures real usage, then we say what to industrialise, consolidate or cut. Idun is backed by Wilco, IMT Starter, Polytechnique X-UP and La French Tech.
The role
There is a gap in the European AI market between the consultancies that can talk about agents and the teams that can actually build them to a production standard. Idun lives in the second group. As a Senior AI Engineer, you are the person building the agents that our clients deploy.
This is a builder role. You will take a scoped use case (a document QA agent, a multi-step compliance workflow, a customer-facing assistant) and take it from architecture through to a production deployment with observability, guardrails, access control, and an eval suite. You will work inside the client's environment, using the Idun Platform as your runtime, and hand off a system the client's team can operate without you.
The work is technically demanding. EU enterprises deploying agents under GDPR and the EU AI Act have real constraints: data must stay in-region, outputs must be auditable, access control must be policy-driven. These are solvable engineering problems, but they require someone who treats them as engineering problems rather than compliance footnotes.
You will also contribute back to the Idun Platform. When a client engagement surfaces a pattern that should be first-class in the runtime (a new memory backend, a guardrail primitive, a better eval harness) you write it up and ship it.
What you'll do
- Architect and build production agents using LangGraph, Google ADK, or Haystack on the Idun Platform: from a rough brief to a deployed, monitored, evaluated system.
- Design the retrieval layer: chunk strategy, embedding models, index schema, query rewriting, re-ranking, eval loops. Make clear-headed RAG vs fine-tuning decisions and defend them with data.
- Wire the full observability stack: OpenTelemetry spans to Langfuse or Phoenix, guardrails policies, audit log schemas, eval metrics. Production readiness means you can show an on-call engineer exactly what happened in any conversation.
- Write eval suites before you declare a component done: unit tests for retrieval precision, integration tests for agent behaviour under adversarial prompts, latency benchmarks against production SLAs.
- Participate in technical scoping with clients: translate a business problem into a component list, flag the hard unknowns early, set realistic delivery expectations.
- Review client engineering teams' agent code during co-build phases; give structured feedback that improves the team's ability to maintain the system after handoff.
- Feed roadmap-worthy patterns and abstractions back to the Idun Engine and Platform teams.
Stack & environment
- Python, LangGraph, Google ADK, Haystack: the three primary agentic frameworks; you are expected to have depth in at least one and breadth across all three
- OpenAI, Anthropic (Claude), Mistral, Cohere: you choose models based on task fit, context window, cost, and data-residency requirements; you are not model-agnostic but you are not model-dogmatic either
- pgvector, Qdrant: the primary vector stores; you have thought carefully about index design and approximate nearest-neighbour trade-offs
- Langfuse, Phoenix: the two trace backends we primarily deploy; you know how to read a trace and diagnose a retrieval or generation failure from span data
- FastAPI, Pydantic, PostgreSQL: the runtime layer; you can read and contribute to Engine internals
- OpenTelemetry: the observability standard; you understand distributed tracing, not just log-level visibility
- Docker, GitHub Actions, pytest: CI/CD and testing
Profile we're looking for
- 3+ years of production AI/ML engineering: you have shipped models or agents that real users interact with, you understand what "production-ready" actually means (not just "it worked in Jupyter").
- Hands-on with at least one of LangGraph, Google ADK, or Haystack in a non-trivial context. You have debugged a streaming failure, a context window overflow, or a guardrail false positive in a live system.
- Clear-headed on RAG vs fine-tuning: you can explain the trade-off in terms of data freshness, latency, cost, and GDPR compliance without reaching for a vendor's marketing comparison chart.
- Eval-first engineering culture: you write evals the way backend engineers write integration tests: not because someone asked you to, but because you consider a system unshipped without them.
- Comfortable in client-facing settings: you can present a technical architecture to a CTO, explain a retrieval failure to a product owner, and flag a scope risk to a programme manager. You do not need a translator between engineering and business.
Why join this role
- Production scope from day one. You are not running experiments or building demos. You are shipping agents that process real enterprise workloads under real SLAs. The feedback loop from "did this work?" is measured in hours, not quarters.
- Technical peer group. You will work alongside engineers who have built and shipped agents at LVMH, Airbus and L'Oréal. The bar is high and the learning curve is steep in the right direction.
- Equity. Early team members receive equity alongside salary. We are transparent about the structure.
- EU AI Act frontier. Deploying agents under the EU AI Act's transparency and auditability requirements is genuinely new engineering territory. The patterns you establish here will be the industry reference.