vs Rama
Rama is a JVM backend platform built around depots, topologies, and PStates. Facts enter an append-only depot, topology code processes them in streaming or microbatch mode, and results land in durable partitioned views shaped for reads. A module is its deploy unit.
Redgold makes the same core bet — one write path, derived views materialized on write, one system covering storage, transforms, and background work — and reaches it from a different direction. The spec is declarative and typed: a checked-in Rust serde schema encoded with CBOR, a pipeline manifest that declares routes and the transforms behind them, transform code an executor runs in a sandbox, and datasets in a data engine that splits a columnar cold tier from a Postgres hot tier. It runs on your own Kubernetes cluster through a Git-backed ArgoCD deploy, and the layer that writes and operates it is a fleet of AI coding agents with model routing underneath them.
The short version of the difference: Rama is a programming model you write in Java or Clojure, engineered for scale and general expressiveness. Redgold is a declarative shape narrow enough that an agent can fill it in and CI can check the result, with the agent runtime, the model API, and the cluster deploy in the same platform.
Shared vocabulary
| Concept | Rama | Redgold |
|---|---|---|
| Source of truth | Depot — an append-only distributed log of facts | An append-only record log behind a single submission path, with content-addressed records carrying source and ingestion time |
| Derived state | PStates — durable views composed from maps, sets, and lists, one per access pattern | Datasets materialized by transforms, several shapes over the same records (data and pipelines) |
| Compute | ETL topologies in streaming or microbatch mode, colocated with storage | Executor-run transforms at request time, plus compute-on-write aggregations driven by a schedule or a change notification |
| Serving | Client API against PStates via paths, plus a REST layer for non-JVM callers | Declared HTTP and WebSocket routes resolved at a stateless edge and dispatched to the executor |
| Deploy unit | A module, launched and scaled with rama deploy / rama scaleExecutors | A Git-backed build to container images, Kubernetes, and ArgoCD (managed deployment) |
| Authoring | A Java/Clojure library, dataflow API intermixed with ordinary code | A Rust serde schema, CBOR record contract, and pipeline manifest plus sandboxed transform code, written by agents or by hand (scaffold a narrow app) |
Criteria
| Criterion | Redgold | Rama |
|---|---|---|
| Programming model | Declarative spec plus transform code in a sandboxed executor; the artifact set is fixed so it can be validated | A general-purpose JVM library with a dataflow API and arbitrary code organization |
| Transactional semantics | Single write path with content-addressed records; no cross-partition transaction guarantee offered at this layer | Microbatch topology writes are cross-partition transactions; ACID semantics with no isolation levels to tune |
| Reactivity | WebSocket streaming at the edge and change-notification-driven transforms | Fine-grained reactive subscriptions that emit minimal diffs on PState changes |
| Storage | Columnar cold tier plus a Postgres hot tier under one addressing model, queryable with SQL and via data APIs | Rama's own partitioned storage behind PStates; integrations for Postgres, Cassandra, Kafka, Kinesis and others |
| Scale evidence | Single-cluster production use by one operator; no published benchmark | Vendor-published database benchmarks and a large Mastodon demonstration |
| Runtime host | Your own Kubernetes cluster, GitOps deploys, standard container tooling | A Rama cluster under its own deployment and licensing model |
| Language | Rust serde schemas, CBOR records, TOML pipeline manifests, and transform code in Rust, with untrusted code confined to a sandboxed UDF path | Java, Clojure, or any JVM language |
| AI and agents | Coding-agent fleet in isolated pods, an OpenAI/Anthropic-compatible model API with routing, and an automated review-and-fix cycle over the same repository (AI agents, LLM API) | None; Rama is a backend platform and you bring your own tooling |
| Maturity | Early, single-operator, external authoring surface still being consolidated (data availability) | Commercial product with documentation and support |
When Redgold fits
Redgold fits when the agents are part of the point. The reason the application shape is narrow is that a narrow shape is checkable: an agent produces a schema, a manifest, transform code, and datasets, and CI plus an automated reviewer can verify each artifact before it deploys. The same platform runs the agents in persistent workspaces, meters their model spend, routes their model calls, and deploys their output to your cluster. The distinguishing Redgold surface is the integration of the application spec with agent execution, model access, review automation, and deployment.