Pipeline Applications

Redgold currently delivers pipeline applications as a managed preview. Redgold operates routing, execution, storage, and deployment. The application behavior remains visible in Git as a small set of customer-reviewed artifacts:

• Rust serde types define request and stored-record shapes;
• pipeline TOML declares routes, stages, datasets, and capabilities;
• Rust transforms contain domain-specific behavior;
• inline tests and example requests define the expected result;
• a generated contract summary records the route, input, output, storage, and permission boundary.

Application creation, dataset provisioning, and deployment are coordinated with Redgold during the preview. The walkthrough below shows the contract a customer reviews within that managed workflow.

Example: support request triage

Suppose an application accepts a support request, classifies it, and writes a typed queue record:

POST /api/app/support/submit
  -> authenticate the workspace
  -> decode SupportRequest
  -> run support-triage
  -> write SupportQueueRow
  -> return the accepted record

The checked-in Rust schema gives SupportRequest the fields id, subject, and body. SupportQueueRow adds category and priority. Released persisted types evolve additively so stored records remain readable.

Pipeline TOML

The manifest makes the application route and its authority visible during review:

name = "support-triage"
description = "Classify and store one support request for the authenticated workspace."
family = "support"
role = "route"
maturity = "preview"

[route]
method = "POST"
path = "/api/app/support/submit"
protocol = "unary"
requires_auth = true
route_scope = "public"
capabilities = ["data_engine"]

[[route.stages]]
kind = "function"
qualified_name = "support-triage"

The reviewed manifest answers concrete questions: which HTTP path exists, whether it requires an identity, which transform runs, and which platform capabilities it may use. During managed publication Redgold validates the TOML, checks route and capability policy, pins the transform artifact, and provisions the application dataset.

Rust transform

The transform contains the domain decision. This excerpt shows the ordinary Rust portion; the transform crate's ABI adapter decodes and encodes canonical CBOR around it.

#[derive(Clone, serde::Serialize, serde::Deserialize)]
struct SupportRequest {
    id: String,
    subject: String,
    body: String,
}

#[derive(Clone, serde::Serialize, serde::Deserialize)]
struct SupportQueueRow {
    id: String,
    subject: String,
    body: String,
    category: String,
    priority: String,
}

fn triage(request: SupportRequest) -> SupportQueueRow {
    let urgent = request.subject.to_lowercase().contains("outage");
    SupportQueueRow {
        id: request.id,
        subject: request.subject,
        body: request.body,
        category: if urgent { "incident" } else { "general" }.to_string(),
        priority: if urgent { "high" } else { "normal" }.to_string(),
    }
}

The checked-in test calls this function with representative records and verifies the emitted row. The production adapter uses the same transform ABI exercised by the batch transform guide.

What the customer controls

Redgold operates the edge, executor, data engine, storage tiers, deployment, and runtime monitoring. A coding agent can propose changes to the artifacts, while the customer reviews the same schema, manifest, transform, and tests that enter the managed release.

Managed change lifecycle

Customer describes a behavior change
  -> an agent proposes schema, TOML, transform, and tests
  -> the customer reviews the Git change
  -> Redgold validates and deploys the approved contract
  -> the customer verifies one bounded request

Self-service publication, portable application catalogs, declarative client surfaces, sharing, and offline installation are later expansions of this contract. Their component-preview details live in the Pipeline Apps overview.

Continue with the pipeline manifest preview for the reviewed TOML subset or author a batch transform for the current Rust execution boundary. The model API and coding agents remain independently usable supporting capabilities.

Keep evolving the application

Follow an application workstream to extend this support app with duplicate-request handling, organize the issues, resolve a blocked decision and verify managed delivery. A request through the platform explains the runtime behind the example.