vs serverless compute
Serverless-compute platforms turn a function into vendor-managed cloud capacity. Modal packages Python functions and runs them on autoscaling CPU or GPU workers with usage-based billing; similar platforms cover batch jobs, inference, and scheduled tasks. The product unit is an arbitrary function with declared compute requirements.
Redgold runs transform code too, but through a different model. The executor resolves a route to a dataflow, and transform stages run over engine storage with content-addressed result caching and signed input/output traces. It is built for computation that reads and writes the platform's datasets, not for hosting general-purpose functions with autoscaling and metered billing.
Criteria
| Criterion | Redgold | Modal-class serverless compute |
|---|---|---|
| Data model | Content-addressed Rust serde rows encoded with CBOR over a Lance/Parquet cold tier and a Postgres hot tier (data and pipelines) | Stateless by default; you bring your own database or object store |
| Deploy target | Your own Kubernetes cluster via a Git-backed build and ArgoCD (managed deployment) | The vendor's cloud; functions scale up and down with no cluster to operate |
| Execution model | Transform stages in a dataflow plan with caching and verifiable traces (build a vertical); executor tiers are in-process built-ins, trusted native (cdylib) transforms, capability-limited Wasmtime UDFs, and untrusted native/Python UDFs in a Firecracker microVM sandbox. GPU UDF execution is absent; the separate request-handler WASM host is a component preview | Arbitrary functions (Python-first) with autoscaling and per-second billing |
| GPU story | Model serving runs on GPUs through the AI serving lane (spot GPUs, vLLM) (AI and agents); the dataflow executor has no wired GPU tier | On-demand GPUs attached per function, scaled and billed by the second |
| Self-host story | Managed during onboarding today; a single-machine Docker Compose evaluation sandbox exists for local trials, with broader self-service self-hosting planned | Hosted-only |
| AI / agent integration | Coding-agent fleet in isolated pods plus model API routing, next to the same data layer (AI agents, LLM API) | General compute; agent orchestration is left to you |
| Maturity | Early, single-operator; the generic external execution surface is still being consolidated (data availability) | Mature, widely used for ML and batch workloads |
Category boundary
Serverless compute centers on arbitrary functions running on vendor-managed workers, commonly with autoscaling and metered CPU or GPU capacity. Redgold's dataflow executor is oriented around transforms over its own engine. Its Wasmtime UDF backend is implemented and default-on, with the first route staged for publication; GPU UDF execution is absent. The feature-gated request-handler WASM host is not selected by production routing. Compute that never reads or writes platform datasets sits outside the main Redgold application shape.
When Redgold fits
Redgold fits when the compute is part of a data pipeline: transforms over datasets where caching, content-addressed reuse, and signed traces matter, running on your own cluster next to the storage and the agents. The unit is a declared application and its data, deployed through GitOps, with model serving and a coding-agent fleet on the same platform.