Member of Technical Staff (Verification Engine)
About ArettaOur mission is to make AI provably trustworthy, starting with the world’s software.
AI is about to write the world’s software. All of it, from the critical infrastructure everything depends on to the apps people use every day. We want a future where people decide what software should do and machines prove that it does. We’re starting with the tools engineers need to ship AI-written code knowing it’s correct.
Within six months of starting, we're deployed with paying design partners in databases and data infrastructure, where we've found 60+ critical bugs, including data-loss bugs that survived their testing and simulation stacks. We're backed by visionaries like Ion Stoica, Kurt Keutzer, Sanjit Seshia, Ram Shriram and Sriram Rajamani. The founders, Sushant and Adwait, were previously PhD and postdoc at UC Berkeley.
The role
This is the core of Aretta. Our engine finds the bugs that slip past our customers’ best testing and simulation, and proves they’re gone where it matters most. No single technique gets you there, so we’re bringing together people who’ve pushed testing and verification forward from different directions. You’ll turn those ideas into systems that run on real customer code at scale, and invent new techniques when nothing out there works. If you care about the software the world runs on being correct, and you’ve built tools that found real bugs or proved real systems correct, this is you.
Expertise that’s relevant here
Testing: coverage-guided and grammar-based fuzzing, deterministic simulation testing (DST), property-based testing (PBT), Jepsen-style distributed-systems testing, linearizability checking, concurrency testing, fault injection and chaos testing, differential, metamorphic and mutation testing, sanitizers, test-case reduction.
Program analysis: static analysis, abstract interpretation, dataflow and taint analysis, CodeQL, Datalog-based analysis, type systems, bug finding at scale.
Symbolic methods: symbolic and concolic execution, SAT and SMT solving (Z3, cvc5), bounded and explicit-state model checking (CBMC, TLA+, Alloy, P).
Proof: interactive and automated theorem proving (Lean, Rocq, Isabelle), program verifiers (Dafny, Verus, F*, Kani, Why3), separation logic, refinement proofs, specification inference and autoformalization.
Languages and infrastructure: programming language design, compilers and intermediate representations (LLVM, MLIR), runtimes, parsers and multi-language tooling, test and CI infrastructure at scale.
You don’t need all of these. One, done deeply, is enough.
Problems you’d own
Verify real systems at scale. Build infrastructure that runs analysis, testing and proof across large, multi-language customer codebases, reliably and fast.
Combine techniques. Decide when to fuzz, simulate, analyze statically, execute symbolically or prove, and build the pipeline that uses each where it works best.
Find the bugs nobody else can. Concurrency and distributed-systems bugs, data loss, crash recovery, consistency violations: build the techniques that find them, including ones specific to databases and data infrastructure.
Make specifications practical. Help engineers and AI agents state what correct means, and check it: invariants, contracts, models, and turning intent in code and docs into formal specifications.
Work with any language. Build the language-level pieces (parsers, intermediate representations, compilers, runtimes) that let our tools work across the languages customers use.
Push the field. Publish, open-source and present where it helps, and bring new research into production.
You don’t need to have done all of this. We care about how you’d approach it.
You might be a fit if
You’ve gone deep on at least one way of finding bugs or proving correctness, and you’re curious about the others. You’ve built tools that found real bugs in real systems, or proved things that mattered. You think in invariants. You care about rigor and about shipping: a technique only counts when it works on someone’s actual code.
You don’t need
A PhD. Many of the best tools in this field were built by engineers.
Experience with AI or machine learning.
Who we hire
We hire at every level, and we mean it. If you’re senior, you’ll come in as a hands-on engineer and grow into leading and building a team. If you’re early in your career, fresh out of school or a few years in, you’ll get real ownership fast and as much scope as you can take on. What matters is the same bar for everyone: mastery, the drive to grow, and the instinct to help others grow too.
More details
Benefits: unlimited PTO, health, dental and vision insurance, and a 401(k).
How we work
We work in roughly six-week cycles: five intense weeks, then a week for reflection, polish, feedback and mentorship. We bring opinionated ideas backed by evidence, bias for action, fix the class of problem rather than the instance, and close the loop with the people we serve. Read more in Our Culture.
Aretta comes from aretē, the Greek word for excellence and virtue: becoming the best version of yourself in everything you do. We value excellence for its own sake, and we believe it’s built across a whole life, not just the hours at a desk.
We work in person in the San Francisco Bay Area. For the right person we’ll consider remote, so don’t let location stop you from applying.
Our hiring process is probably unlike any you've been through, so please read about it before you apply. Everyone joins Aretta the same way: No puzzles, no whiteboards, and the process typically takes about a week end to end (subject to scheduling availability). You share real work you've done, then we spend a few hours on a real problem together to get a mutual feel for working side by side. Learn more here: How We Hire.