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
Work at the boundary with the inference team. Own fleet-wide routing, placement, and capacity; hand off to the Inference Engineer for per-model serving performance (batching, KV-cache, quantization) rather than owning that layer yourself
Strong systems engineering background on distributed cloud control planes and multi-tenant orchestration at scale (e.g., Kubernetes-style schedulers)
Comfort being a high-impact IC rather than a manager
Track record building reliability from scratch
Experience with resource scheduling or bin-packing algorithms for heterogeneous compute pools
Experience with multi-cluster federation or distributed consensus systems (Raft, ZooKeeper, or similar)
Comfort with hardware heterogeneity/ambiguity
Genuine interest in being an early hire at a ~6–7 person company
Experience with distributed job schedulers or cluster orchestration systems (Kubernetes, Nomad, Slurm, or similar)
Experience running non-NVIDIA accelerators (TPUs/ASICs) in production
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
You will design and build the network our inference fleet runs on. Every rack we buy has to be racked, cabled, connected, and turned into capacity the platform can use. The network is what makes that happen. There's no existing network team, no inherited topology, and no reference architecture to copy. You'll build it right the first time, knowing it has to scale site after site.
The problem is also new. The fleet is heterogeneous by design. GPUs handle prefill, and decode runs on accelerators from several ASIC vendors, each with its own interconnect requirements and management tooling. You'll define how those systems connect to each other, to our customers, and to the internet. You'll do it as part of the Data Center Deployment team that stands up every new site.
What you'll do:
Design and own the data center network architecture: the leaf-spine fabric, the high-bandwidth, low-latency paths between GPU prefill and ASIC decode systems, and out-of-band management
Lead the network build-out for each new site: bill of materials, rack elevations and cabling plans, cross-connects, and bring-up through acceptance testing
Turn each accelerator vendor's networking requirements into one consistent fleet design
Set up external connectivity: IP transit, peering, and private connections to customers
Build tenant isolation and network security in from day one, not bolted on after the first enterprise customer asks
Automate configuration, provisioning, and validation against a real source of truth, so site five goes up faster than site one
Build monitoring and telemetry for the fabric, and own network incident response
Manage network hardware vendors, carriers, colocation providers, and remote-hands teams
Work at the boundary with the platform team. Own the physical and L2/L3 network, fabric performance, and site connectivity. Hand off to the Platform Engineer for fleet-wide request routing, model placement, and scheduling rather than owning that layer yourself
What we need from you:
Hands-on experience designing and deploying data center networks, not only operating existing ones
Deep routing and switching knowledge for modern DC fabrics: BGP, EVPN-VXLAN or equivalent, ECMP, leaf-spine design
Experience building high-performance networks for AI/HPC clusters or other latency-critical environments (RDMA/RoCE, InfiniBand, congestion control, 400G/800G optics)
Network automation skills (Python, Ansible, or similar) and comfort treating network config as code
Comfort on the data center floor: working through cabling, optics, and hardware failures yourself or by guiding remote hands
Comfort with hardware heterogeneity and ambiguity
Genuine interest in being an early hire at a ~6–7 person company
Nice-to-haves:
Networking experience with non-NVIDIA accelerators (SambaNova, Cerebras, TPU pods, or similar)
Multi-tenant cloud networking and tenant isolation at scale
Experience with transit contracts, peering, and internet exchanges
Network source-of-truth tooling (NetBox, Nautobot) and streaming telemetry (gNMI)
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.
Right now, our presence on X and LinkedIn is generated by a contractor and pushed out by our founders — which means it only happens when a founder makes it happen. That's backwards. We want someone who owns the channel outright: who shows up at hackathons with a camera and a point of view, who posts because something happened today, not because a content calendar said to.
This is not a \"run our social calendar\" role. It's broader than social: events, dinners, out-of-home advertising, office activations, and a technical content channel sharp enough to help us recruit the engineers we need. You'll be the person who makes General Compute feel alive online and in the room — and increasingly, the person other founders and engineers think of when they think of us.
Own X and LinkedIn end-to-end. Find the moments worth posting, be there to capture them and drive daily conversation without waiting on a founder.
Run founder-led social. Shape the public voice of our founders and grow their presence without them having to drive it.
Be on the ground. Attend hackathons and industry events, create content live and publish it the same day.
Run in-person moments. Run dinners, events, office activations and out-of-home campaigns that give people a reason to talk about us, and make sure each one shows up online.
Build a recruiting channel. Make technical content credible enough that skeptical senior engineers, whether potential hires or customers, get curious about what we're building.
A track record of being online — an active, credible presence of your own on X and/or LinkedIn, not just professional experience managing someone else's.
Bias toward action over polish: comfortable generating live, in-the-moment content rather than long-form, heavily produced pieces.
Genuine enjoyment of being out in the world — at hackathons, dinners, events — not just planning them from behind a screen.
Enough technical fluency (or hunger to build it) to produce content that reads as credible to engineers, not generic marketing copy.
Full ownership mentality: you're the one who notices what's missing and fixes it, not the one waiting for a brief.
Industry background in AI/infra/startups — helpful for credibility and sourcing content, but not required if you're a fast learner with the right instincts.
Experience running events, activations, or out-of-home campaigns in addition to social.
Prior experience as an early or founding marketing hire at a startup, where you had to build the function rather than fit into an existing one.