Member of Technical Staff, Safety & Formal Verification

General Diffusion, Inc.; San Francisco, Northern (CA, KY); Hybrid; USD 180,000 - 260,000; Full time

Job summary

General Diffusion, Inc. is seeking a Member of Technical Staff in Safety & Formal Verification to build an independent assurance layer that gates, elevates, or reverses actions outside learned policies.

The role focuses on formalizing hard operating limits and semantic-preservation claims across heterogeneous execution stacks. You will work with Runtime, Compilers, Kernels, and RL teams to translate contracts into verifiable interfaces, ensuring independent safety sign-off for permitted actions

Qualifications

• Experience applying formal methods to real systems (not just coursework).
• Strong grounding in semantics and refinement reasoning.
• Practical engineering fluency in verification tooling.

Responsibilities

• Specify safety invariants and predicates for action placement and execution.
• Design an independent admission-control and authority-gating layer.
• Build runtime monitors and validation checks with deterministic violation records.
• Create adversarial and counterexample tests for authority boundaries.
• Collaborate with Runtime, Compilers, Kernels, and RL teams to translate contracts into verifiable interfaces.

Skills

Formal methods

Operational semantics

System judgment

Safety cases

Verification tooling

Tools

Model checking tools

SMT solvers

Theorem proving

Job description

Member of Technical Staff, Safety & Formal Verification

Build the independent machinery that can reject a compute action regardless of model confidence.

Status Open

Area Safety

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, elevate, 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.

01 / The work

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, elevate, 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.

02 / The background

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.

03 / The evidence

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.

04 / In the system

Where this role fits

Owns assurance and permitted-action checks; Security Engineering owns adversarial access and isolation.