General Compute is the neocloud for alternative chips.
Inference is fragmenting: purpose-built silicon from SambaNova, Cerebras, Positron, d-Matrix, and others already beats GPUs on decode, and we productionize that hardware — we buy the racks, find the data center space, and run it for our customers. Each piece of hardware runs the workload it's actually built for: prefill stays on GPUs, decode moves to the chip built for it, and today that means generating tokens 5–7× faster than existing GPU-based competitors. Our customers are frontier labs, fast-growing AI application companies, and asset-light clouds.
We closed a $15M seed round in May 2026, and have since closed a $400M debt facility — $100M funded upfront by Upper90, with the balance available for drawdown — collateralized by our inference chips.
You'll own the infrastructure layer of our inference cloud end-to-end. Today that means the control plane, the gateway in front of our ASIC fleet, and the observability stack that tells us where every millisecond goes. Over the next 6-8 months, it will grow into a heterogeneous fleet: ASICs for decode, GPUs for pre-fill, and the physical-layer ownership that comes with it.
The first six months are hands-on: k8s manifests, dashboards, oncall, and a direct line to our ASIC partner's engineering team when production behaves strangely. The team grows under you from there.
Own the inference control plane. At the moment, it's built on configuration provided by our ASIC partner; you'll be the person who understands it deeply enough to modify, extend, and eventually replace pieces of it.
Own the gateway and load balancer that fronts the fleet. Model placement, request routing, and tail-latency engineering live here, driven by live utilization and per-model SLOs.
Own observability end-to-end. Per-request tracing from OpenRouter ingress through to the accelerator, with p50/p95/p99 dashboards, SLOs, and alerting that wakes the right person.
Run capacity planning against a real, distributed traffic mix across the open-weight models we serve.
Own the operational side of the ASIC partnership. Most weird production issues route through their engineering team until we build that expertise in-house, and you'll be our technical face in those conversations.
Bring up the pre-fill side of our disaggregated architecture on a second hardware platform as it comes online. Different vendor, different fabric, different kernels.
Build the on-call and incident response practice from zero. Hire and grow the team underneath you.
7+ years in infrastructure, SRE, or platform engineering, with at least some of it at a serious inference, ML, or HPC shop.
Hands-on with Kubernetes at production scale — not just deploying, but debugging the weird stuff.
Strong instincts for tail latency. You think about p99 and utilization as the same problem, not different ones.
Comfortable owning a vendor relationship where the vendor's bugs are now your production issues.
Track record of building observability practices that actually catch problems, not just generate dashboards.
Have been on-call through real incidents and can talk about what you learned.
Want to be the first infra hire at something early, not the tenth at something big.
Experience operating non-NVIDIA accelerators in production — TPUs, ASICs, or alternative GPU vendors.
Background with model-serving stacks (vLLM, TGI, TensorRT-LLM, SGLang).
Network fabric experience at data-center scale (RoCE, InfiniBand).
Have hired and managed an infra team before.
Comfort at the hardware boundary — firmware, drivers, thermals — for when the roadmap takes us there.
About Us
General Compute is the neocloud for alternative chips.
Inference is fragmenting: purpose-built silicon from SambaNova, Cerebras, Positron, d-Matrix, and others already beats GPUs on decode, and we productionize that hardware — we buy the racks, find the data center space, and run it for our customers. Each piece of hardware runs the workload it's actually built for: prefill stays on GPUs, decode moves to the chip built for it, and today that means generating tokens 5–7× faster than existing GPU-based competitors. Our customers are frontier labs, fast-growing AI application companies, and asset-light clouds.
We closed a $15M seed round in May 2026, and have since closed a $400M debt facility — $100M funded upfront by Upper90, with the balance available for drawdown — collateralized by our inference chips.
About the role
This is the first dedicated capital markets hire at General Compute, reporting directly to the CEO. You'll own our capital stack end-to-end — structuring and closing financing facilities, running lender relationships, and building the credit story that carries us into our Series A. It's a hands-on seat: you build the models yourself, run the process yourself, and spend the bulk of your week on capital markets, with the rest keeping core company finance tight.
What you'll own
Own the first asset-backed facility end-to-end: model, data room, lender process, term sheets, close.
Own the capital stack from here — subsequent debt tranches, customer contract financing, and the credit story we take into Series A.
Own every credit relationship we have.
Run day-to-day company finance: cashflow, budget vs actuals, and our bookkeeper. About a day a week — the other four are capital markets.
What we need from you
You have personally closed a $50M+ asset-backed or equipment-backed facility in compute, data center, or comparable infrastructure — CoreWeave, Crusoe, Lambda, Nebius, Voltage Park, Applied Digital, or a leveraged finance / ABL desk that ran the work on a deal like ours.
You build the model yourself.
You move fast. The first facility closes in the next few months.
You are direct. We have no time for hedging.
You are comfortable being an early employee — hands-on with everything finance, including the unsexy parts.
You will report to the CEO and have meaningful equity tied to delivery.
General Compute is the neocloud for alternative chips.
Inference is fragmenting: purpose-built silicon from SambaNova, Cerebras, Positron, d-Matrix, and others already beats GPUs on decode, and we productionize that hardware — we buy the racks, find the data center space, and run it for our customers. Each piece of hardware runs the workload it's actually built for: prefill stays on GPUs, decode moves to the chip built for it, and today that means generating tokens 5–7× faster than existing GPU-based competitors. Our customers are frontier labs, fast-growing AI application companies, and asset-light clouds.
We closed a $15M seed round in May 2026, and have since closed a $400M debt facility — $100M funded upfront by Upper90, with the balance available for drawdown — collateralized by our inference chips.
General Compute is seeking a leader to own the physical build-out of our ASIC compute infrastructure — from delivered hardware to production-ready cluster, and everything it takes to keep it running once it's live.
Cluster Deployment: Own hands-on deployment of ASIC compute clusters end-to-end: oversee hardware install, rack-and-stack, cabling, power-up, and commissioning through to production readiness.
Facility Engineering & Operations: Lead data-center engineering operations — power, cooling, and network infrastructure — for every site we bring online, and keep it running once it's live.
Deployment Program Ownership: Set and own deployment timelines and quality bar across sites. Commissioning, testing, and punch-list — you close it out.
Technical Partner to Site Sourcing: Translate cluster power density, cooling, and network requirements into technical specs for the team sourcing power and colocation capacity — you don't own the deal, but you own whether the site can actually run our hardware.
Vendor Management: Oversee relationships with hardware vendors, remote-hands providers, and commissioning contractors on the technical side of delivery.
Team Building: Build and lead the deployment and ops team as our physical footprint scales.
Direct, hands-on experience deploying or commissioning GPU or ASIC compute infrastructure at scale — at a compute infrastructure company (CoreWeave, Crusoe, Lambda, Nvidia, a hyperscaler, or similar) or as a senior data-center operations leader.
Track record leading data-center engineering and operations teams: commissioning, facility engineering, cluster bring-up, and steady-state reliability.
Technical fluency in power, cooling, and networking as they relate to high-density AI compute.
Comfortable being hands-on early — this is a builder role on a small team, not a steady-state operations seat.
Ability to move fast — \"first cluster online in the next few months.\"
Direct communication style and willingness to do hands-on physical infrastructure work personally when needed.
General Compute is the neocloud for alternative chips.
Inference is fragmenting: purpose-built silicon from SambaNova, Cerebras, Positron, d-Matrix, and others already beats GPUs on decode, and we productionize that hardware — we buy the racks, find the data center space, and run it for our customers. Each piece of hardware runs the workload it's actually built for: prefill stays on GPUs, decode moves to the chip built for it, and today that means generating tokens 5–7× faster than existing GPU-based competitors. Our customers are frontier labs, fast-growing AI application companies, and asset-light clouds.
We closed a $15M seed round in May 2026, and have since closed a $400M debt facility — $100M funded upfront by Upper90, with the balance available for drawdown — collateralized by our inference chips.
You'll take a new model and get it running — correctly — on our ASIC in record time. When a frontier model drops, the only question that matters is how fast we can land it on our silicon and start serving it. You own that loop: from reference weights, through the compiler, to first correct tokens. The low-level runtime is co-owned with our hardware partner today; your job is everything it takes to get a brand-new architecture compiled, verified, and fast on top of it.
The bet of this role is that bring-up should be an agentic loop, not a hand-port. You'll build the harness of agents that compiles, runs, diffs against reference, and localizes failures — so the marginal model comes up faster than the last one did. Correctness first, optimization second: get it right, prove it's right, then make it cheap. This is a senior IC role on a small team. You'll own the bring-up pipeline, not tickets.
What You'll Do:
Own model bringup end-to-end. Take a new architecture — a frontier LLM, an MoE, a multimodal model — from reference weights to first correct tokens running on our ASIC, in days, not quarters.
Build the agentic bringup loop. The differentiator isn't hand-porting one model — it's the harness of agents that compiles, runs, diffs against reference, localizes the failing op, and iterates without you in the inner loop. Each model you land should make the loop better at landing the next one.
Live in the compiler. Graph capture, IR lowering, op coverage, kernel selection — when a model won't compile or produces wrong numbers, the fix is yours, whether it's a missing lowering, a fused-kernel bug, or a numerics mismatch.
Own correctness before speed. Build the verification harness — layer-by-layer activation diffs, logit parity, end-to-end evals — that proves a freshly brought-up model matches reference before anyone trusts a token of it.
Then optimize. Once it's correct, make it fast: operator fusion, quantization, memory layout, batching and KV-cache behavior on our hardware. Bringup gets it running; this is where it earns its cost-per-token.
Work shoulder-to-shoulder with our hardware partner's compiler and runtime team. You're the person who turns 'the chip can technically run this' into 'this model is live and correct in production.
What we need from you:
5+ years in systems or ML systems, with real depth in at least one of: ML compilers, model porting/bringup, or high-performance kernels.
You've taken a model architecture you didn't design and made it run — and run correctly — on a target it wasn't written for. Numerics debugging doesn't scare you.
Strong on the internals of modern LLM inference: transformers, attention, KV cache, MoE routing, quantization, batching. You can read a new model's reference implementation and know what will be hard to lower.
Comfortable inside a compiler stack — MLIR/LLVM, XLA, or a vendor graph compiler — at the level of IR, lowering, and op coverage, not just calling into one.
Fluent with agentic tooling. You'd rather build the agent that runs the tedious bringup loop than run it by hand — and you have the taste to know where the loop still needs a human.
Self-directed. We don't assign tickets — you'll see the next model coming and have it half brought-up before anyone asks.
Nice-to-haves:
Have worked on a non-NVIDIA accelerator — TPU, Trainium/Inferentia, Tenstorrent, Groq, Cerebras, or similar — at the compiler or model-bringup layer.
Kernel-level experience in CUDA, Triton, or a vendor kernel language. You know why a fused attention kernel beats three unfused ops.
Have built eval and numerics-verification harnesses (logit parity, activation diffing) for models in production.
Contributed to a graph compiler or serving runtime — XLA, TVM, MLIR, vLLM, TGI, TensorRT-LLM, or SGLang.
Have built agent loops or LLM-driven tooling that did real engineering work, not demos.
General Compute is the neocloud for alternative chips.
Inference is fragmenting: purpose-built silicon from SambaNova, Cerebras, Positron, d-Matrix, and others already beats GPUs on decode, and we productionize that hardware — we buy the racks, find the data center space, and run it for our customers. Each piece of hardware runs the workload it's actually built for: prefill stays on GPUs, decode moves to the chip built for it, and today that means generating tokens 5–7× faster than existing GPU-based competitors. Our customers are frontier labs, fast-growing AI application companies, and asset-light clouds.
We closed a $15M seed round in May 2026, and have since closed a $400M debt facility — $100M funded upfront by Upper90, with the balance available for drawdown — collateralized by our inference chips.
Getting a model correct and fast on our silicon is only half the problem — the other half is serving it. You'll build and own the inference layer that sits between a bought-up model and a live customer request: request scheduling, batching, KV-cache management, autoscaling across our ASIC fleet, and the failure modes that only show up at real traffic and real scale.
This is a founding role on a small team, which means the scope is wide and the ownership is real: there's no separate SRE org to hand reliability to and no platform team to hand infra to. You'll design the serving architecture, then be the person paged when it breaks. The bet is that a serving stack built specifically for our hardware — not adapted from a GPU-first framework — is a durable edge, and you're the person who proves that out in production.
Own the inference serving stack end-to-end. Design and build the system that takes a bring-up-verified model and serves it in production: request routing, batching, scheduling, and autoscaling a single model's serving replicas.
Push cost-per-token down. Continuously tune batching strategy, KV-cache handling, and hardware utilization to widen the throughput advantage over GPU-based serving.
Build for reliability from day one. Put in place the monitoring, alerting, and failover that make a fast-moving inference stack trustworthy under real customer load — and be the one who responds when it isn't.
Work at the boundary with the compiler and bring-up team. Define the interface between \"a model is correct and compiled\" and \"a model is live and fast,\" and push issues back to the right side of that line.
Shape the roadmap, not just the backlog. As a founding engineer, you'll help decide what we build next in serving — multi-tenant isolation, speculative decoding, new scheduling strategies — not just execute a spec someone else wrote.
Set the technical bar for the team you're helping build. Early architecture and code-quality decisions you make here will shape how the serving team operates as it grows.
5+ years building and operating production systems at the infrastructure layer, ideally including a high-throughput or low-latency serving system.
Direct experience with LLM inference serving — request batching, KV-cache management, continuous batching, or similar — in a production environment, not just research code.
Comfortable owning reliability: you've been on call for a system that mattered, and you design for failure rather than reacting to it after the fact.
Strong systems fundamentals — concurrency, networking, scheduling — deep enough to reason about performance at the hardware level, not just the application level.
Self-directed and comfortable with ambiguity. This is a founding role: there's no existing playbook to follow, and you'll help write it.
Experience serving models on non-NVIDIA accelerators (TPU, Trainium/Inferentia, Tenstorrent, Groq, Cerebras, or similar).
Familiarity with serving frameworks such as vLLM, TGI, TensorRT-LLM, or SGLang, and an opinion on where they fall short.
Experience running infrastructure at a small company or in a founding/early-engineer capacity before.
Exposure to capacity planning or fleet management for specialized hardware.
General Compute is the neocloud for alternative chips.
Inference is fragmenting: purpose-built silicon from SambaNova, Cerebras, Positron, d-Matrix, and others already beats GPUs on decode, and we productionize that hardware — we buy the racks, find the data center space, and run it for our customers. Each piece of hardware runs the workload it's actually built for: prefill stays on GPUs, decode moves to the chip built for it, and today that means generating tokens 5–7× faster than existing GPU-based competitors. Our customers are frontier labs, fast-growing AI application companies, and asset-light clouds.
We closed a $15M seed round in May 2026, and have since closed a $400M debt facility — $100M funded upfront by Upper90, with the balance available for drawdown — collateralized by our inference chips.
You will build the inference cloud itself — the control plane, API, and serving layer that turn racks into a sellable product. There's no existing platform team to inherit or manage, no legacy system to work around, and no established playbook to follow — just the platform itself to build, with reliability treated as core infrastructure from day one rather than something bolted on after the first outage.The technical problem is also genuinely unsolved elsewhere. The fleet is heterogeneous by design — GPUs for prefill, multiple ASIC vendors for decode — so there's no single-vendor playbook to lean on; you'll be defining how a mixed-hardware inference cloud gets scheduled, routed, and served reliably, in close partnership with the teams standing up the physical fleet.
Build/own the control plane — routing, model placement, scheduling across a mixed ASIC/GPU pool
Build the API and serving layer exposing rack capacity as a sellable product
Build in reliability and observability from day one
Scale the platform ahead of the demand curve
Partner closely with data center deployment and model bring-up teams
Be a founding technical voice on platform architecture
Strong systems engineering background on cloud control planes/serving infra at scale
Comfort being a high-impact IC rather than a manager
Track record building reliability from scratch
Comfort with hardware heterogeneity/ambiguity
Genuine interest in being an early hire at a ~6–7 person company.
LLM-serving infra experience (vLLM, TGI, Ray Serve, etc.)
Experience running non-NVIDIA accelerators (TPUs/ASICs) in production.