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.