Open role · Safety
Member of Technical Staff, Safety & Formal Verification
Build the independent machinery that can reject a compute action regardless of model confidence.
Build the independent assurance layer that decides whether a proposed compute action is permitted, rather than trusting learned-model confidence or a reward signal. You will formalize hard operating limits and semantic-preservation claims across General Diffusion’s heterogeneous execution stack, then turn them into evidence that can gate, escalate, or reverse bounded runtime authority. This role supports the company’s public direction of constrained planning, kernel semantic verification, and runtime constraint enforcement while remaining independent of policy learning and security access control.
What you’ll work on
- Specify machine-checkable safety invariants and permitted-action predicates for placement, execution, and recovery paths; make their assumptions, environment model, and failure semantics explicit.
- Design an independent admission-control and authority-gating layer that can reject, escalate, or require reversal of an action outside the learned policy and its confidence estimates.
- Build semantic-equivalence or refinement-validation workflows for generated and transformed executable artifacts, including clear treatment of unsupported features, bounds, nondeterminism, and reference assumptions.
- Develop runtime monitors and reference-validation checks that connect formal properties to observable execution behavior, with deterministic violation records and handoff paths.
- Create adversarial, fault, rollback, and counterexample-driven test scenarios that demonstrate behavior at authority boundaries before broader rollout.
- Partner with Runtime, Compilers, Kernels, and RL teams to translate execution contracts into verifiable interfaces and actionable counterexamples; retain independent safety sign-off for permitted actions.
What you bring
- Experience applying formal methods to real systems—for example, model checking, SMT-based verification, theorem proving, abstract interpretation, or runtime verification—not only coursework or toy proofs.
- Strong grounding in operational semantics, refinement/equivalence reasoning, and the limits of a proof under assumptions such as bounded exploration, undefined behavior, concurrency, or hardware models.
- Hands-on systems judgment in a compiler, runtime, scheduler, distributed system, or performance-critical service, including how failures surface in production-like execution.
- Ability to design safety cases that combine specifications, proof or validation artifacts, tests, runtime telemetry, and explicit residual-risk statements.
- Practical engineering fluency in building reproducible verification tooling, debugging solver counterexamples, and communicating precise contracts across research and systems teams.
What progress looks like
- A reviewed assurance case maps the first set of high-consequence compute actions to explicit invariants, environmental assumptions, ownership, enforcement points, and defined escalation or reversal behavior.
- A reproducible validation suite produces pass, fail, and inconclusive evidence for representative semantic-preservation and action-permission cases, with counterexamples retained as regression tests and proof bounds reported rather than hidden.
- A controlled end-to-end exercise shows that an independently enforced violation can block or withdraw action authority, preserve the relevant evidence, and route a diagnosable signal to the responsible runtime or policy owner.
Where this role fits
Owns assurance and permitted-action checks; Security Engineering owns adversarial access and isolation.
Apply
Interested in this role?
Email your background and a short note about the work you would like to do.
careers@generaldiffusion.com