Senior Rust Engineer — Autheo | Live Mainnet Runtime, Post-Quantum Execution & DevHub SDKs

Launch Legends•Cheyenne, WY

2d•Remote

About The Position

Autheo is recruiting a Senior Rust Engineer to own memory-safe execution and cryptography on a chain that is already live. Mainnet has been up since May 14, 2026. Staking and fees settle on-chain. DevHub is open. Post-quantum primitives, TheoID, Marketplace compute and storage, and THEO AI are rolling onto that network. The job is not to invent a ledger in a slide. It is to make the Rust path in the Eigensphere Engine something a protocol engineer can ship against, and something a DevHub user can call without reading the node. You will build and harden Rust components for execution, cryptographic operations, and the developer surface around them: WASM-compatible runtime modules, proof and signature verification on the post-quantum roadmap (Kyber, Dilithium, Falcon), gRPC and GraphQL boundaries used by DevHub and cross-chain flows, and SDKs in Rust and JavaScript. You will sit with protocol, security, and DevRel. You will not own exchange listings, the OCC charter, or the product roadmap. Part-time does not mean advisory. Equity cofounder means you own a surface, write the code, and review the code next to it.

Requirements

Production Rust. Ownership, lifetimes, async (Tokio or equivalent), and error types you have operated, not listed.
Shipped backend services with gRPC or GraphQL, and a tracing story (OpenTelemetry or equivalent) you can walk through.
Distributed systems work you can defend: retries, idempotency, backpressure, or a consensus-adjacent path.
Comfort in Kubernetes and a CI pipeline that builds and tests Rust.
Ability to read a cryptographic spec and implement against test vectors.
Bachelor’s or Master’s in Computer Science or equivalent practical depth.

Nice To Haves

Post-quantum or zero-knowledge implementation experience is strongly preferred; a serious systems engineer who has shipped crypto-adjacent code (signatures, key rotation, secure enclaves, WASM sandboxing) will be considered.
WASM runtimes (wasmtime or equivalent), blockchain execution (Cosmos SDK, EVM client, Solana runtime, or a zkVM), or a DePIN / marketplace compute path.
Open-source Rust that a stranger can clone and run.
Regulated or audit-facing backends (healthcare, payments, SOC 2). Useful, not required.
A public artifact: a crate, a paper, a talk, or a design doc. We will read it.

Responsibilities

Design and ship Rust modules in the Eigensphere execution path: deterministic WASM-compatible components, safe host calls, and clear resource limits for contract and DePIN compute tasks.
Use Rust’s ownership model on purpose. No unsafe blocks without a written reason, a test, and a reviewer who understands the invariant.
Profile hot paths on the live network and on replay. Report p50/p99 and allocation behavior. Do not advertise a throughput number the cluster has not measured.
Implement and integrate post-quantum primitives already on the Autheo roadmap: Kyber / ML-KEM, Dilithium / ML-DSA, and Falcon / SLH-DSA, behind versioned interfaces the rest of the stack can call.
Build verification and proof-checking libraries that embed in the runtime. Prefer a named proving system, a measured proof size, and a measured verify time over a slogan.
Add field-level encryption and key-handling boundaries where Marketplace or TheoID metadata must move without exposing it. Differential privacy only where a real epsilon, a dataset, and a threat model exist.
Own gRPC and GraphQL contracts for runtime and cross-chain operations, with schema evolution, idempotency, and backpressure.
Apply saga or equivalent durable workflows where a multi-step flow can tear (IBC packet, bridge message, Marketplace job). Name the failure mode.
Webhook and event delivery for DevHub and dApp consumers: idempotency keys, per-endpoint health, and a latency budget you can show on a trace.
Kubernetes deploys, circuit breakers, and readiness that match how the validator and API surface actually run.
OpenTelemetry across the paths you own, so an on-call engineer can follow one transaction without a private Slack thread.
Benchmarks in CI (criterion or equivalent) on the cryptographic and execution paths, so a regression is a failed check and not a surprise on Mainnet.
Rust and JavaScript SDKs for the operations you ship, with a short path from docs to a working call.
Sandbox or replay tooling so a DevHub user can test a runtime module without a production key.
Reviews, written design notes, and mentorship of the engineers on the same surface.