Founding ML Engineer

Moss is building the retrieval runtime for real-time AI. We help agents access the right knowledge, conversation history, and user context in milliseconds, and use that context to decide what to do next.

We’re looking for a Founding ML Engineer to own the models and machine learning systems behind that experience. You’ll work across embeddings, retrieval, reranking, multilingual understanding, agent intelligence, and our Action Layer; taking ideas from experiments into production.

The work comes with real constraints: limited memory, CPU execution, changing context, multiple languages, and latency budgets that leave little room for error. Your job is to improve intelligence and quality while making the models practical to run.

What You’ll Do

• Train and fine-tune embedding and reranking models for real-world retrieval workloads.
• Build multilingual embedding models that retrieve accurately across languages, regions, and mixed-language conversations.
• Improve the intelligence behind our Founding Agent. From understanding intent and retrieving context to choosing better responses and converting conversations into meaningful outcomes.
• Help build Moss’s Action Layer, enabling agents to move from retrieving context to determining and executing the right next action.
• Own the full model-development cycle: dataset creation, training, evaluation, optimization, deployment, and iteration.
• Build evaluation pipelines that measure retrieval relevance, multilingual quality, agent outcomes, latency, memory usage, and inference cost.
• Improve model efficiency through distillation, quantization, and inference optimization, particularly for CPU and ARM devices.
• Work with runtime and SDK engineers to ship models across cloud, browser, edge, and device environments.
• Investigate production failure cases and turn them into better datasets, evaluations, and models.
• Make practical decisions about what to train, what to adapt, and what to ship.

Core Stack

The work spans:

• Python and deep learning frameworks for training and experimentation.
• Embedding models, rerankers, contrastive learning, and semantic retrieval.
• Multilingual and cross-lingual representation learning.
• Agent evaluation, intent understanding, tool selection, and action prediction.
• Dataset curation, hard-negative mining, synthetic data, and reproducible evaluation.
• Model distillation, quantization, and portable inference.
• Moss’s Rust runtime and SDKs across cloud and on-device environments.

You don’t need to have worked with every part of the stack. You do need to understand how model decisions affect the system running them and the user experience they create.

Your First 90 Days

From day one: Work directly with our models, evaluation pipelines, Founding Agent, and production use cases. Start contributing code and experiments immediately.

• By 30 days: Understand the current quality and performance baselines. Own a concrete improvement to a model, dataset, evaluation pipeline, or Founding Agent capability, with evidence that it solves a real problem.
• By 60 days: Take a model improvement through evaluation and deployment. This could mean improving multilingual retrieval, making the Founding Agent more effective, or advancing an Action Layer capability. Work with the engineering team to validate its behavior under realistic hardware and workload constraints.
• By 90 days: Independently own a meaningful part of the ML roadmap. Identify the next bottleneck, define the experiments, and drive improvements into production without waiting for a tightly scoped task.

What We’re Looking For

• Experience training or fine-tuning models and deploying them into production.
• Strong foundations in representation learning, information retrieval, and model evaluation.
• Strong Python skills and the ability to write maintainable code beyond a research notebook.
• An understanding of how training data, objectives, and evaluation choices affect real-world model behavior.
• Ability to reason about tradeoffs between quality, latency, memory, and compute.
• Comfort working through ambiguous problems and owning the result.
• Clear communication about what you tried, what worked, what failed, and what should happen next.

Nice to Have

• Experience with embedding models, rerankers, or search relevance.
• Experience building multilingual or cross-lingual models.
• Experience evaluating or improving conversational agents.
• Experience with tool selection, action prediction, or agentic systems.
• Experience deploying models on CPU, ARM, mobile, or browser environments.
• Work on distillation, quantization, or inference performance.
• Familiarity with Rust or systems-level performance profiling.
• Research or open-source contributions relevant to efficient ML, retrieval, or agents.

Who You’ll Work With

You’ll work directly with the founder and our ML, runtime, backend, product, and SDK engineers. You’ll also work with the team supporting customer deployments, so your priorities stay connected to how people actually use Moss.

Why Moss

Moss is a YC F25 company building infrastructure for AI applications that need relevant context and the ability to act on it in real time.

You’ll have ownership over core technology: the models we build, how we evaluate them, how they improve our Founding Agent, and how they power the Action Layer. There’s room to pursue new ideas, and a clear expectation that those ideas become useful, reliable software.

If you want to build models and own what happens after they leave the training environment, we’d like to talk.

About the company

Moss is building the real-time semantic search runtime for conversational and multimodal AI. Our system enables voice agents, copilots, and chat interfaces to retrieve, reason, and respond in sub-10 ms, delivering the responsiveness that makes AI interactions feel truly natural.

If you’ve ever built a conversational or voice AI product, you’ve felt the lag. That moment when an agent pauses and the illusion of intelligence breaks. The bottleneck is almost always retrieval. Each query hops across networks and databases, adding delay and cost. Moss eliminates that gap by keeping retrieval close to where the agent runs.

Moss runs natively across browsers, mobile devices, and servers with an optimized vector index built in Rust and WebAssembly. It enables teams to build AI products that feel instant, contextual, and adaptive. The experiences that sustain engagement and unlock new kinds of interaction. For our customers, this translates into tangible business value: stronger user retention, higher conversion, and entirely new product categories made possible by real-time understanding. Moss is already powering production pilots across voice AI and developer platforms, achieving sub-10 ms retrieval and 70–90% token savings compared to traditional pipelines.