AI Architect / Tech Lead (mahjong game)

Neurons-Lab; España; Presencial; EUR 90.000 - 120.000; Jornada completa

Descripción de la vacante

Neurons-Lab is seeking a Hands-on Tech Lead to own the Mahjong AI companion for an online social game. You will design and implement a robust mahjong-playing algorithm, explore RL/imitation learning or search-based strategies, and ensure a strict 2-second move latency with an LLM reasoning layer.

You will own the architecture end-to-end, collaborate with the client CTO and product owner, supervise a small AI engineering pod, and drive the project within a 3-month, 0.5 FTE ramp.

Formación

• Hands-on ML/AI engineering at production scale.
• Shipped an AI system inside a live product with hard latency limits.
• Cloud hyperscaler experience (AWS preferred).
• Technology consulting / client-facing delivery background.

Responsabilidades

• Design and build the mahjong-playing algorithm: choose and defend the approach (imitation learning on hand histories, RL / self-play, search with MCTS, or a hybrid).
• Own the technical architecture end to end: game model + LLM reasoning layer, valid-action mask, win detection, and API contract with client game bridge.
• Hit the 2-second response budget: design and measure the inference path, batching, and caching.
• Define data/event names to collect from the client; build training/calibration pipeline.
• Build and run the evaluation harness: measure play strength against client reference points and validate explanations.
• Stand up LLM observability with Langfuse as an early sprint win.

Conocimientos

Game AI / sequential decision-making

Python

Model training on gameplay data

LLM application engineering

Low-latency inference

LLM observability

AWS deployment for ML workloads

Technical leadership

Herramientas

Langfuse

MCTS

APIs / CI

Descripción del empleo

About the project (description, duration, stage)

Hands-on Tech Lead for an AI Companion in an online mahjong game. The client is a social gaming company (web3 element) that scales its product and team. We deliver the AI side of their game as their embedded AI partner.

The AI Companion plays mahjong at a strong level and explains its moves. The core of the role is to build the mahjong-playing algorithm: a dedicated decision-making model (RL, imitation learning, or search-based - trained on the client's hand-history data) with an LLM reasoning layer on top. Key design constraints: a valid-action contract with the game engine (the bridge supplies legal moves), win detection, and a 2-second response budget per move. Explanations run async. Support for more than one rule set (riichi and regional variants) is on the roadmap.

Duration: 3 months, 0.5 FTE.

What you'll actually do (example tasks)

• Design and build the mahjong-playing algorithm: choose and defend the approach (imitation learning on hand histories, RL / self-play, search with MCTS, or a hybrid), then train, evaluate, and ship it.

• Own the technical architecture end to end: game model + LLM reasoning layer, valid-action mask, win detection, and the API contract with the client's game bridge.

• Hit the 2-second response budget: design and measure the inference path, batching, and caching; keep a latency buffer for the client-facing number.

• Define what data and event names we need from the client (hand histories, event streams); build the training and calibration pipeline on that data.

• Build and run the evaluation harness: measure play strength against the client's reference points, and validate explanation quality.

• Stand up LLM observability with Langfuse (async logging, N+1 batch) as an early sprint quick win.

• Take over context from Vlad Borysenko (0.15-0.2 FTE supervision during ramp-up) and lead the sprint work with the AI Engineer; work with the client's Product Owner in a scrum process.

• Front the client's CTO and engineers on technical decisions; explain trade-offs in plain language and in depth when asked.

• Watch the risks the account team flagged: licensing on new training data, engine-bridge capabilities, and multi-rule-set scope.

Skills (hands-on first)

• Game AI / sequential decision-making: hands-on RL, imitation learning, or search-based agents (MCTS, self-play) - ideally for imperfect-information games (mahjong, poker, card games)

• Expert Python for ML systems; strong software engineering (APIs, testing, CI)

• Model training on gameplay data end to end: data → training → evaluation → serving

• LLM application engineering: reasoning layers, prompt and context design, structured outputs, guardrails

• Low-latency inference: profiling, batching, caching, model-size trade-offs against a hard time budget

• LLM observability and evaluation (Langfuse or similar)

• AWS deployment for ML workloads

• Technical leadership of a small pod; clear written and spoken communication with client engineers and executives

Knowledge

• Game theory for imperfect-information games; evaluation of play strength (win rates, Elo-style ratings, baseline agents)

• Game-engine integration patterns (event streams, action masks, state bridges)

• Web3 / gaming product context — plus, not required

• AWS Well-Architected for ML workloads

Experience

Key characteristics (ideally 4/4):

• Hands-on ML/AI engineering at production scale

• Shipped an AI system inside a live product with hard latency limits

• Cloud hyperscaler experience (AWS preferred)

• Technology consulting / client-facing delivery background

Role-specific characteristics:

• 6+ years hands-on ML/AI engineering, with real game AI or sequential decision-making work (RL / MCTS / self-play - not only LLM apps)

• Trained models on user or gameplay data end-to-end (data → training → evaluation → serving)

• Led small delivery teams while still coding personally

• Comfortable owning an architecture in front of a technical client CTO

Questions for Applicants

• Imperfect information: mahjong hides most tiles from each player. How does hidden information change your algorithm choice compared to a perfect-information game like chess?

• Latency budget: tell us about a system you shipped with a hard response-time limit. How did you design, measure, and defend the budget?

• LLM + model hybrid: how would you combine a trained game model with an LLM explanation layer so the explanation never contradicts the move?

• Hands-on + lead: how do you balance personally coding the hard parts with leading an engineer and fronting the client?