MTS · Engineering · Systems (Rust)

Nebula is the system of state for enterprise agent workflows, and at its center is a Rust engine that owns how state is represented, stored, queried, and updated. The engine implements Nebula's Hierarchical Vector Graph (HVG) — structured nodes, typed edges, vector representations, and provenance — over a three-tier storage architecture spanning in-memory cache, local NVMe, and S3-compatible object storage. Over time, we expect more of its relationships and execution model to move into latent space.

This role owns and evolves that engine — query execution, indexing, concurrency, storage behavior, and performance as datasets grow from terabytes toward petabytes. It focuses on the performance-critical engine itself, not the cloud infrastructure and deployment systems around it.

What you'll work on

• Own and evolve the Rust engine that represents, stores, queries, and updates Nebula state.
• Improve execution for HVG traversal, retrieval, filtering, ranking, and index access.
• Extend indexes that combine graph structure, vector representations, structured metadata, and provenance.
• Optimize Nebula's three-tier storage system across memory, local NVMe, and object storage.
• Improve caching, residency, prefetching, promotion, eviction, persistence, and recovery across storage tiers.
• Keep frequently accessed state available at sub-millisecond latency as graphs and workloads grow.
• Strengthen coordination under concurrent reads, writes, retries, eviction, and partial execution.
• Improve memory layout, allocation behavior, synchronization, serialization, and CPU efficiency across latency-sensitive paths.
• Scale execution across processes and Kubernetes pods, including partitioning, routing, hotspot mitigation, and workload rebalancing.
• Build and optimize low-latency gRPC interfaces between the engine and Nebula's service layer.
• Profile and debug lock contention, cache misses, excessive allocation, memory pressure, storage stalls, uneven partitions, and p99 latency regressions.
• Keep the engine understandable and maintainable as its query surface, storage model, and scale expand.

Depending on the week, you might optimize a traversal primitive, remove contention from a write path, improve index locality, redesign an eviction policy, investigate a tail-latency regression, or change how graph state is partitioned across workers.

What we're looking for

• Strong production experience with Rust.
• Experience building performance-sensitive systems such as databases, storage engines, query engines, runtimes, compilers, networking systems, or distributed services.
• Strong intuition for concurrency, memory management, data layout, networking, persistence, and storage tradeoffs.
• Experience reasoning about correctness under concurrent reads and writes.
• Experience working with datasets larger than memory, tiered storage, caching, buffer management, or durable persistence.
• Comfort profiling performance across CPU, memory, locking, allocation, serialization, storage, and network boundaries.
• Experience with partitioning, replication, coordination, or state ownership across processes or nodes.
• The ability to build abstractions that remain simple as performance requirements and system surface area grow.
• High ownership and comfort working on systems whose architecture is still evolving.

We care more about demonstrated systems judgment and the quality of systems you have built than a particular number of years of experience.

Nice to have

• Experience building graph databases, vector databases, query engines, storage engines, search systems, or language runtimes.
• Experience with graph traversal, query planning, indexing, ranking, or execution optimization.
• Experience with approximate nearest-neighbor indexes, embeddings, or retrieval over latent representations.
• Experience with page or buffer management, compaction, write-ahead logging, snapshots, or recovery.
• Experience with lock-free or low-contention data structures.
• Experience designing distributed partitioning, replication, consensus, or failover mechanisms.
• Experience optimizing gRPC, Protobuf, or other latency-sensitive RPC systems.
• Familiarity with systems spanning memory, local NVMe, and object storage.

Why Zeroset

• Own the engine and state representation at the center of Nebula.
• Work across the full systems stack, from memory layout and query execution to durable storage and distributed partitioning.
• Shape fundamental decisions around graph representation, latent retrieval, indexing, concurrency, and tiered storage.
• Scale a working system toward terabyte- and petabyte-scale graphs while preserving low latency on critical read paths.
• Join a small, technical team with high trust, low bureaucracy, and direct access to founders and customers.
• Build foundational infrastructure for agents operating across long-running, real-world enterprise workflows.