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.