Artificial Intelligence Engineer

Gangkhar-ES; Comunidad de Madrid; Presencial; EUR 70.000 - 95.000; Jornada completa

Descripción de la vacante

Gangkhar is building an AI-driven insurance infrastructure and seeks an AI Engineer to shape the agent platform powering Sherpa Mesh. You’ll own multi-agent systems, integrate with Azure Foundry and OpenRouter, and collaborate with architects to translate client specs into production-grade agents.

Bring 5+ years of backend experience, strong TypeScript/Node.js skills, PostgreSQL ownership, and a product mindset. Security, GDPR, and observability are part of daily work.

Formación

• 5+ years building and operating backend systems.
• 1–2 years building LLM-based agents in production.
• Strong TypeScript/Node.js ownership and PostgreSQL.
• Comfortable reading Python and using LLM APIs directly.
• Experience with Docker and Kubernetes in production.
• Security and GDPR awareness.
• Product-minded with architectural judgment.
• Familiarity with open agent interoperability protocols a plus.
• Cost and latency reasoning for token budgets and model choices.

Responsabilidades

• Design, build, and deploy LLM-powered agents and multi-agent systems.
• Build agent loops, tool calls, and context engineering against LLM APIs.
• Extend and operate the agent memory pipeline (extraction, retrieval, injection).
• Take evaluation harness from early production to offline eval suites.
• Implement observability: tracing, token accounting, debugging tools.
• Apply guardrails and governance: PII handling, access controls.
• Integrate agents with internal APIs via MCP for real-world actions.
• Balance speed, quality, and scalability in engineering trade-offs.

Conocimientos

TypeScript/Node.js

PostgreSQL

HTTP API design

Job queues

Python reading

LLM-based agents

Docker/Kubernetes

Azure

Security/GDPR

Product mindset

Cost/latency reasoning

Herramientas

Docker

Kubernetes

Azure Foundry

OpenRouter

MCP

Descripción del empleo

At Gangkhar, we’re building the next-generation insurance infrastructure. Our AI-native protection platform enables partners to design, deploy, and scale world-class protection programs in just a few weeks.

We're looking for an AI Engineer with a hands-on mindset and a product mentality. You'll build the agent platform that powers Gangkhar: the infrastructure where AI agents are designed, evaluated, governed, and operated at scale. You'll work on Sherpa Mesh, our internal reference agent platform built and maintained by our infrastructure team — extending it, building on it, and, when needed, contributing to it directly. You'll collaborate closely with the architects who own client discovery and agent design, turning their specs into production-grade agents.

What Kind of Engineer We’re Looking For

This is a role for an engineer who cares how the code is built, not only whether it runs.

• You build capabilities, not one-offs. Faced with a stakeholder-specific request, you find the reusable shape underneath it — and you know when a request genuinely is specific.
• You think in modules and boundaries. You know what belongs together, what doesn't, and you can say why.
• You design before you type, and you can defend a design in a conversation with an architect and in plain language with a non-technical stakeholder.
• You are precise: clear names, explicit behaviour, no guessing at what a function does from the outside.
• You leave a codebase more coherent than you found it, and you read an unfamiliar system with its grain before proposing changes.
• You work with coding agents daily and own every line they produce. Output volume is free now; judgment is the scarce part — we want engineers who reject their agent's work, not who ship it.
• If "it works for this client, ship it" is your standard, this isn’t the role.

Your Impact

• Design, build, and deploy LLM-powered agents and multi-agent systems within Sherpa Mesh, our internal agent platform (agent manifests, registry, runtime, delegation, fleet coordination).
• Build directly on LLM APIs served through Azure AI Foundry and OpenRouter: agent loop, tool calling, context engineering, without heavyweight orchestration frameworks.
• Extend and operate the agent memory pipeline — extraction, property injection, retrieval — within the existing attribute/property/memory architecture.
• Take the evaluation harness from early-stage production signal detection to a real offline eval suite: datasets, graders, regression tests, and the promotion gate that decides what goes to production.
• Implement observability for agentic systems: run-level tracing, token accounting, debugging tools.
• Apply guardrails and governance: attribute-based access policies, PII handling, human-in-the-loop flows.
• Integrate agents with internal APIs and business systems via open protocols (MCP) to trigger real-world actions.
• Make pragmatic engineering trade-offs between speed, quality, and scalability.

What You Bring

• 5+ years building and operating backend systems. Deep, not broad-and-shallow — plus 1–2 years building LLM-based agents or GenAI systems in production.
• Strong TypeScript/Node.js, and the judgment to use the type system rather than fight it. Real production ownership of PostgreSQL, HTTP API design, job queues— not just familiarity.
• Comfortable reading and writing Python — not your main language, but you'll touch it.
• Experience building agents directly against LLM APIs, and the judgment to explain why you didn't reach for a framework.
• Judgment about context engineering, tool design, and retrieval — the interesting problems are in the interfaces, not the prompts.
• Experience with retrieval architectures: RAG pipelines, knowledge base construction, and general understanding of graph-based retrieval (GraphRAG, knowledge graphs).
• Experience with evals and LLM observability (eval harnesses, tracing, quality metrics).
• Deployment with Docker and Kubernetes; cloud experience (Azure preferred).
• Awareness of security and compliance: GDPR, PII masking, access control, AI safety mechanisms.
• Product mentality: you understand the business logic behind what you're building, not just the spec. When an architect's design has a gap or doesn't hold up in practice, you push back with a better alternative — you don't build it blind and let it fail downstream.
• Familiarity with open agent interoperability protocols (A2A, Agent Cards) is a plus.
• Cost and latency reasoning — you can estimate token budgets and per-query costs, and know when to route to a cheaper or faster model instead of defaulting to the biggest one

Tech Stack

TypeScript on Node.js, with Hono. PostgreSQL for storage, background jobs via a job queue. Model access through Azure AI Foundry and OpenRouter. MCP for agent interoperability. Deployed on Docker/Kubernetes in Azure. Python for evaluation tooling. Go and Preact exist in the codebase (CLI, internal devtools) but sit with the infrastructure team, not day-to-day for this role.

Languages

Spanish and Fluent in English (required)