Senior System Engineer

OB Collective; Greater London; Remote; GBP 90,000 - 120,000; Full time

Job summary

OB Collective is seeking a Senior Systems Software Engineer – Verification & Security to join a UK-based, mostly remote team. You will develop verification mechanisms behind a government-facing R&D programme, ensuring correctness, evidence integrity and deterministic behavior across challenging edge cases.

The role emphasizes strong Rust experience or equivalent security-focused systems background, with a preference for backend engineering in Go, C++, or Java.

Qualifications

• Experience delivering backend software where correctness and failure behavior are critical.
• Strong practical capability in Rust or equivalent systems language.
• Experience with automated testing and debugging complex behavior.
• Understanding of structured data, APIs, services, or reusable libraries.

Responsibilities

• Develop and extend the existing verification software.
• Build structured evidence records for automated actions.
• Implement evidence processing, canonicalisation and integrity checks.
• Develop deterministic, versioned verification functionality.
• Ensure failed or incomplete evidence is not misrepresented as success.
• Implement checks around evidence freshness, timing and action association.
• Handle incomplete inputs and boundary conditions of complex systems.
• Enable reproducible replay and re-verification capabilities.
• Create machine-readable outcomes, failure information, and reason codes.
• Write automated tests for unusual inputs and adversarial scenarios.
• Apply testing techniques like property-based testing or fault injection.
• Contribute to code reviews, security work, and release stabilization.

Skills

Backend engineering

Rust

Security-critical systems

Automated testing

Debugging complex behavior

Cryptography basics

Distributed systems

Linux

Git

Tools

Linux

Git

Job description

OB Collective develops independent verification technology for organisations operating in government, regulated and high-assurance environments. Our work is concerned with establishing reliable evidence about information and automated actions before organisations rely on them.

We’re building a senior technical team for a six-twelve month engagement on a UK public-sector R&D programme focused on the cybersecurity and operational assurance of AI agents. We’re looking for a Senior Systems Software Engineer – Verification & Security to develop the core verification mechanisms behind the programme.

As AI agents gain access to organisational data, credentials, tools, APIs and enterprise systems, organisations need stronger ways to establish whether required conditions were satisfied around consequential actions. The programme will extend an existing software capability to provide independently verifiable evidence, identify uncertainty and test how verification behaves under incomplete information, failure and adversarial conditions.

There is an existing technical capability and a defined research direction. The engineering challenge is to extend that capability while ensuring that incomplete, stale, inconsistent or failed evidence cannot silently be represented as successful verification.

You will work closely with the Principal Technical Lead to build and refine the underlying software, with substantial responsibility for correctness, evidence integrity, deterministic behaviour, reproducibility and failure handling.

This is a hands-on engineering position requiring someone who can build reliable software, reason carefully about difficult boundary conditions, diagnose unexpected behaviour and establish confidence through rigorous testing.

Strong Rust experience is preferred, but candidates with excellent security-sensitive systems or backend engineering experience in Go, C++, Java or comparable languages will also be considered.

The role is UK-based, outside IR35, full-time and primarily remote, with occasional travel for workshops and technical activity.

What you’ll do

• Develop and extend the existing verification software.
• Build structured evidence records associated with specific automated actions.
• Implement reliable evidence processing, canonicalisation and integrity mechanisms.
• Develop deterministic and versioned verification functionality.
• Ensure failed, degraded and insufficient evidence is represented explicitly rather than treated as successful verification.
• Implement checks around evidence freshness, timing, action association and other critical conditions.
• Handle incomplete observation, delegated access and difficult system-boundary conditions.
• Build reproducible replay and re-verification capabilities.
• Develop clear machine-readable outcomes, failure information and reason codes.
• Create automated tests covering unusual inputs, degraded conditions and adversarial behaviour.
• Use seeded failures, property-based testing or comparable techniques to establish correctness.
• Investigate implementation, resilience and performance issues identified through evaluation.
• Contribute to code review, technical security work, documentation and release stabilisation.

What we’re looking for

• Strong hands-on backend, systems or infrastructure software engineering experience.
• Experience developing software where correctness, integrity and failure behaviour are critical.
• Strong practical capability in Rust or a comparable systems/backend language.
• Experience with reliable software design, automated testing and debugging complex behaviour.
• Understanding of structured data, APIs, services or reusable software libraries.
• Understanding of data integrity and practical cryptographic mechanisms such as hashing and signing.
• Ability to reason carefully about incomplete inputs, state, timing and failure.
• Experience maintaining or extending established production codebases.
• Ability to explain what software can and cannot establish from available evidence.
• Confidence working collaboratively on architecture, implementation and technical reviews.

Preferred experience

• Production Rust engineering.
• Applied cryptography.
• Secure logging, provenance or tamper-evident records.
• Distributed systems and event-driven architectures.
• Deterministic replay, event sourcing or verification systems.
• Property-based testing or formal verification techniques.
• IAM, policy evaluation or security-control integration.
• Fault injection, resilience engineering or performance testing.