Software Engineer - Orchestration

Join the EIT as a Software Engineer, building the software that makes autonomous laboratories work. You will be part of the AI and Robotics Institute, working within a multidisciplinary team of software, mechanical, electrical, robotics, and AI research engineers, alongside the plant scientists who are our users.

We are building the execution engine for autonomous laboratories. The central problem is that AI systems are stochastic and laboratory hardware is not. A robot arm holding a plate of live plant tissue needs bounded, repeatable, recoverable behaviour, while the agents deciding what to try next work nothing like that. Your work is the layer in between, turning an agent's intent into a sequence of actions the lab can execute safely, holding it inside what the hardware and the biology allow, and handling what happens when something fails at three in the morning with a fortnight of growth on the line.

In practice that means scheduling work across instruments that cannot be in two places at once, defining the surface an agent is permitted to touch alongside what needs a human to sign it off, and giving scientists a way to describe a protocol and watch it run. A recurring theme is closing the loop, since assuming a command was obeyed is rarely good enough.

Depending on the problem that might mean vision to confirm a dispense, force feedback to seat labware, or bounding the action space of a learned policy so its proposals can be validated before anything moves. We do not expect you to arrive with all of these. We do expect you to be the kind of engineer who is comfortable picking up an unfamiliar technique, trying it, and discarding it if it turns out to be the wrong answer.

The systems you write control real hardware doing real biology, so correctness, recoverability, and observability matter more here than they do in most software work.

• Design and build the software that orchestrates autonomous laboratory systems, including scheduling, workflow execution, state management, error handling, and recovery.
• Develop the agentic layer of our platforms, covering tool interfaces for LLM agents, planning and decision logic, and the guardrails and human approval steps that sit around anything touching physical hardware.
• Close control loops with sensing, so that the system verifies what happened rather than assuming a command succeeded, and fails in a way that leaves the workcell in a known state.
• Develop and maintain integrations with laboratory hardware, covering robot arms, liquid handlers, incubators, imagers, and plate readers, working from vendor SDKs, serial and network protocols, and occasionally sparse documentation.
• Build and extend internal Python libraries and services, with attention to clear interfaces, testability, and the ability to simulate hardware so that logic can be developed and tested without occupying the lab.
• Design data models and pipelines for experimental data, sample tracking, and provenance, so that results are traceable from raw instrument output back to the protocol and physical sample that produced them.
• Work directly with scientists to understand manual protocols, then translate them into automated workflows, iterating as the biology and the hardware both reveal their constraints.
• Use AI coding tools as a core part of your workflow, and help establish the practices that make this effective and reviewable across the team, including context management, tooling configuration, testing discipline, and knowing when to stop delegating and write the code yourself.
• Contribute to engineering practice across the team, covering code review, CI, testing strategy, deployment, documentation, and the shared standards that keep a fast-moving codebase maintainable.
• Support commissioning and debugging in the lab, since a meaningful share of software problems in this domain only appear when the hardware is moving.

• Solid software engineering fundamentals, covering version control, code review, CI/CD, debugging, and API design.
• Fluency with design patterns and architectural structure, at both the object level and the system level, together with the judgment to apply them where they earn their place rather than by reflex.
• Strong professional Python, including type hints, testing, packaging, async where appropriate, and the sense to know which of these a given problem needs.
• Experience designing and building systems rather than scripts, with a track record of code that other people have depended on and maintained.
• Practical experience using agentic AI coding tools such as Claude Code, Cursor, or equivalent, with a considered view of where they help, where they fail, and how to review their output.
• Experience integrating with external systems, whether hardware, third‑party APIs, or messy legacy interfaces.
• Comfort working with ambiguity, in an R&D setting where requirements are discovered through building.
• Strong communication and collaboration…