About The Role

Alpha isn’t a chatbot sitting on top of a product. It’s an agent that reads a customer’s account, reasons about their plan, and prepares real orders for them to confirm. The model is the easy part. The hard part is everything around it: the tools it calls, the context it sees, how a request gets routed, the guardrails that keep it away from anything that must be exact, and the deterministic systems underneath that place orders, move money and consume events.

You’ll own parts of that system end to end, from spec to production. When something goes wrong in a conversation, you’ll be the one who opens the traces and finds where the run went wrong. You’ll decide whether the fix belongs in a tool, a prompt, the routing, the backend or the model, and prove it with an eval. Then you’ll explain it so product, design and other squads can act on it.

Much of the work crosses squads. Alpha integrates with Thndr’s order, funding, savings and market-data services, so you’ll write proposals other teams adopt as well as code. We also work with served models beyond Alpha, so some of the work goes below the API: choosing, evaluating, fine-tuning and serving models for other Thndr products.

We work through coding agents every day. We expect you to be very good at running your own and at helping others fix their workflows.

This is an R&D role, and we hire for breadth on purpose. Most of your time goes to Alpha, but the same person who fixes a routing failure on Monday might be benchmarking an open model, prototyping an agent for another squad, or testing whether a new technique is worth adopting by Friday. We expect you to pick up unfamiliar problems quickly, take them from research to something running in production, and know when an experiment should stop.

What You'll Do

• Own parts of Alpha end to end. Take a module, such as a tool family, the evaluation pipeline or an integration, and be accountable for how it behaves, its quality in production, and its long-term health. Don’t just follow the design we have: change it when it’s wrong.

• Design the harness. Tool contracts that read as the model’s instructions, context the model can use, routing between capabilities, and guardrails that move must-have rules out of prompt text and into code. Start from the behaviour a customer needs and work back to the component.

• Build observability and evaluation that people trust. Read traces before building dashboards. Categorise real failures and fix the most upstream one first. Build evals that check the resulting state, not just the final message. Validate LLM judges against human labels. Know the noise floor before calling something a win or a regression.

• Run Alpha like a production service. Own latency, reliability and cost for your area: time to first token, end-to-end turn latency, streaming, provider rate limits and fallbacks, and cost per conversation. Set the budgets, monitor them, and get paged when they break.

• Engineer the deterministic parts properly. Retrieval, event consumers that drive automated execution, planning and allocation logic, and integrations with money-moving services, with idempotency, retries and reconciliation. Keep the LLM away from anything that has to be exact.

• Work below the API when it pays off. Evaluate, fine-tune and serve transformer models for Alpha and other Thndr products. Run the model lifecycle like software: versioned data and evals, reproducible training, safe rollout and rollback.

• Turn questions into decisions. Take a vague “is this working?” and answer it with data: SQL over production traces, experiment design, and choosing between prompting, routing, fine-tuning or a different model. Then communicate the answer so non-specialists act on it.

• Lead cross-squad proposals. Write designs that other squads adopt for integrating Alpha with their systems, and take them from proposal to shipped.

• Raise the team’s bar. Review other engineers’ designs and evals, and help teammates improve how they work with coding agents: instructions, verification, review discipline.