Skip to content
AggregaAggrega
Select language: English

Examples by product and capability

Every example in this folder, listed first in the order to work through them, tier by tier, then under each product it deploys and under each capability it shows. Each entry gives the example’s level and the first sentence of its page.

The level is start, authoring or advanced: the levels The header on each example lists. The header each example carries, and the lists its values come from, are described in The header on each example.

In teaching order

Start here

Tier start-here: the two examples Getting started grows one step at a time, then the two starters for the cloud.

  • quickstart-ai (start) — A small LangGraph agent, grown in four steps: it starts on a local model with a memory, gains a cloud model with the local one as its fallback, gets guardrails in front of both, and finally builds for Kubernetes.
  • quickstart-web (start) — A small web application that keeps notes in PostgreSQL, grown in four steps: it starts with its database on your machine, gains a Redis cache, moves to AWS with the database on Amazon RDS, and finally gets its backups.
  • terraform-rds (authoring) — A single MariaDB database authored once as developer intent and rendered to a Terraform HCL file that provisions a managed AWS RDS instance.
  • cloudformation-rds-stack (advanced) — A managed database and the application that reads it, authored once as developer intent and assembled into AWS CloudFormation stack templates.

Catalog only

Tier catalog-only: assembled from catalog entities, with nothing authored but the Aggregate, the Manifest and the Release.

  • catalog-only (start) — This example deploys a small, real stack — a MariaDB database with an Adminer web UI in front of it — by referencing standard-library catalog entities only.
  • cert-manager-tls (start) — This example compiles a small, real stack — a cert-manager certificate controller — from one Developer-authored Aggregate to Kubernetes.
  • contour-gateway (start) — This example compiles a small, real stack — a Contour ingress gateway — from one Developer-authored Aggregate to Kubernetes.
  • external-secrets-operator (start) — This example compiles a small, real stack — the external-secrets operator — from one Developer-authored Aggregate to Kubernetes, backed by the official external-secrets Helm chart.
  • sealed-secrets-controller (start) — This example compiles a small, real stack — the sealed-secrets controller — from one Developer-authored Aggregate to Kubernetes, backed by the official sealed-secrets Helm chart served from an HTTPS chart repository.
  • openbao-secrets (start) — This example compiles a small, real stack — a single OpenBao secrets server — from one Developer-authored Aggregate to Kubernetes, backed by the official OpenBao Helm chart.
  • jaeger-tracing (start) — This example compiles a small, real stack — a Jaeger distributed-tracing backend in its single-node shape — from one Developer-authored Aggregate to Kubernetes, synthesized directly from the official Jaeger image with no upstream chart.
  • tempo-tracing (start) — This example compiles a small, real stack — a Grafana Tempo distributed-tracing server — from one Developer-authored Aggregate to Kubernetes via Workload synthesis on the official grafana/tempo image, in its single-binary shape.
  • loki-logging (start) — This example compiles a small, real stack — a Grafana Loki log-aggregation server — from one Developer-authored Aggregate to Kubernetes, backed by the official Grafana Loki Helm chart in its single-binary shape.
  • kafka-broker (start) — This example compiles a small, real stack — an Apache Kafka event-streaming broker in its single-node KRaft shape — from one Developer-authored Aggregate to Kubernetes, synthesized directly from the official Apache Kafka image with no upstream chart.
  • redis-cache (start) — This lean example compiles a single Redis in-memory cache (Redis wire protocol) from one Developer-authored Aggregate to two realizations.
  • valkey-cache (start) — This lean example compiles a single Valkey in-memory cache (Redis wire protocol) from one Developer-authored Aggregate to two realizations.
  • memcached-cache (start) — This lean example compiles a single Memcached in-memory cache from one Developer-authored Aggregate to two realizations.
  • nats-messaging (start) — This example compiles a single NATS messaging server (pub-sub, request-reply, queueing) from one Developer-authored Aggregate to two realizations.
  • rabbitmq-broker (start) — This example compiles a single RabbitMQ message broker (AMQP) from one Developer-authored Aggregate to two targets.
  • mysql-standalone (start) — This lean example compiles a single MySQL database from Developer-authored Aggregates to two targets.
  • mariadb-helm-synth (start) — A single MariaDB database rendered on Kubernetes by the helm provider’s Workload synthesis — no external chart.
  • postgres-init-config (start) — core/datastore/postgres exposes two optional developer values that shape the database’s first start: init_scripts (SQL or shell run once on initialization) and custom_config (a postgresql.conf fragment).
  • grafana-dashboards (start) — This example compiles a single Grafana dashboards and visualization server from one Developer-authored Aggregate to two realizations.
  • s3-object-store (start) — This example compiles one S3-compatible object store, the core/storage/s3-object-store component, to its two self-hosted realizations.
  • nginx-gateway (start) — This example compiles a small, real stack — an NGINX reverse-proxy gateway fronting a web backend — from one Developer-authored Aggregate to two targets.
  • prometheus-scrape (start) — This example compiles a small, real stack — a Prometheus metrics server scraping two Grafana dashboards servers — from one Developer-authored Aggregate to two targets.
  • fluentd-aggregator (start) — This example compiles a Fluentd log aggregator — the receiving end of a log pipeline — from one Developer-authored Aggregate to two realizations.
  • fluent-bit-to-fluentd (start) — This example compiles a real log pipeline — a Fluent Bit forwarder shipping records to a Fluentd aggregator over the forward protocol — from one Developer-authored Aggregate to two realizations.
  • mysql-innodb-cluster (start) — A MySQL InnoDB Cluster and the control plane that reconciles it, built twice from one unchanged Aggregate: once asking for a single server instance, once asking for three.
  • apisix-stack (start) — This example compiles a small, real stack — a dynamic API gateway — to synthesized Kubernetes manifests from one Developer-authored Aggregate.
  • ferretdb-stack (start) — This example compiles a small, real stack — a document database exposing the MongoDB wire protocol — to synthesized Kubernetes manifests from one Developer-authored Aggregate.
  • kong-stack (start) — This example compiles a small, real stack — a database-backed API gateway — to synthesized Kubernetes manifests from one Developer-authored Aggregate.
  • keycloak-stack (start) — This example compiles a small, real stack — a database-backed identity server — to synthesized Kubernetes manifests from one Developer-authored Aggregate.
  • thanos-stack (start) — This example compiles a small, real stack — the read/query tier of a Thanos metrics system — to synthesized Kubernetes manifests from one Developer-authored Aggregate.
  • harbor-stack (start) — This example compiles a real container registry to Kubernetes manifests from one Developer-authored Aggregate.
  • credential-secretkeyref (start) — A single PostgreSQL database whose password is supplied by the credential subsystem, shown per provider.
  • model-api-key-sharing (start) — Two CrewAI agents behind one OpenAI-compatible gateway.
  • adhoc-uses-socket (start) — This example teaches one line, and both halves of it.
  • ai-agent-and-model-router (start) — An agent application that reaches two upstream provider models through one in-cluster router, compiled to Kubernetes manifests.
  • connection-credentials (start) — A semantic-memory store reaching two models and presenting a different key to each, compiled to Kubernetes manifests.
  • ai-gateway-log-masking (start) — A support assistant has to work with customers’ names and email addresses, so the model it calls must see them.
  • ai-gateway-prompt-injection-shield (start) — A support assistant’s users can type anything, and some of what they type tries to make the model ignore the instructions it was given.
  • ai-gateway-semantic-cache (start) — A support assistant is asked the same questions all day in slightly different words.
  • apisix-token-budget (start) — A team puts two OpenAI models behind one gateway and wants a ceiling on what the gateway spends on them each day, counted in tokens.
  • envoy-ai-gateway-token-budget (start) — A team puts OpenAI’s gpt-4o-mini behind an in-cluster gateway, wants a ceiling on the tokens the gateway spends on it each calendar month, and points its agent at the gateway rather than at OpenAI.
  • nemo-guardrails-nemoguard-nims (start) — An agent’s model requests pass through NVIDIA NeMo Guardrails, which checks each one with two of NVIDIA’s NemoGuard models, licensed NVIDIA products that need a licence from NVIDIA, an NGC API key and a GPU node to run.
  • model-server-caller-allowlist (start) — A model server running in a cluster answers whoever reaches its address.
  • task-run-on-demand (start) — A task carrying core/manual-trigger, deployed without starting on Kubernetes, Docker Compose, Terraform and CloudFormation, beside a task carrying nothing, with the command that starts a run on each target.
  • datastore-backup (start) — A PostgreSQL database backed up on Kubernetes through Velero and through CloudNativePG, and on AWS through Amazon RDS’s own automated backups, on Terraform and on CloudFormation, and through AWS Backup, from one core/backup attachment the operator writes in each Release, with the refusal on a target that has no backup product.

Authoring

Tier authoring: writes a Component, a Feature or a Recipe of its own, or shows how one is shaped.

  • mariadb-adminer (authoring) — This example compiles a small, real stack — a MariaDB database with an Adminer web UI in front of it — from a single Developer-authored Aggregate to two platforms.
  • per-instance-recipe-override (authoring) — This example teaches one Manifest feature: the name mapping tier, which overrides the Recipe for a single component instance while every other instance of the same type keeps the bulk type-tier Recipe.
  • workload-library-import (authoring) — A single stateless web service whose Recipe synthesizes its Kubernetes Workload from a shared library entry instead of an inline body.
  • workload-identity-binding (authoring) — A single stateless app rendered on Kubernetes by the helm provider’s Workload synthesis — no external chart.
  • multikey-secret-synth (authoring) — A single stateless app rendered on Kubernetes by the helm provider’s Workload synthesis — no external chart.
  • mariadb-bitnami-credential-set (authoring) — A single MariaDB database realized by the Bitnami Helm chart, whose passwords are supplied by one multi-key referenceable secret (core/referenced-secret-set).
  • credential-shape-per-target (authoring) — How a credential reaches a running container is a property of where you deploy, not of the application.
  • terraform-rds-module (authoring) — The same MariaDB intent as the terraform-rds example, rendered through the sourced shape of the Terraform provider: instead of an inline HCL body, the Recipe points at a local Terraform module and the compiler vendors it verbatim, then supplies its input variables from the developer and operator pillars.
  • postgres-three-realizations (authoring) — A PostgreSQL database and the application that reads it, deployed three different ways from one unchanged Aggregate: PostgreSQL running in the cluster, PostgreSQL as a managed cloud instance, and a PostgreSQL server that already existed before this Release was deployed.
  • mcp-address-from-secret (authoring) — Some Model Context Protocol servers that someone else runs read their key from their own address — https://mcp.example.com/mcp?api_key=<key> — rather than from a request header.
  • chart-from-git-repository (authoring) — A Helm chart does not have to come from a chart registry.
  • extends-wrapper (authoring) — This example teaches one thing: a Component that extends another inherits that base’s whole data contract, so every Recipe written for the base already implements the extending Component.

Advanced

Tier advanced: boundaries, governance policy, annotation-driven Features and assembled cloud stacks, several combined in one build.

  • advanced-platform (advanced) — A multi-boundary Kubernetes platform that combines several mechanisms in one build from a single Developer-authored Aggregate: boundary-scope FeatureRecipes, parameter hoisting, the credential subsystem, and cross-boundary references resolving through Service DNS.
  • aws-rds-and-ecs-service (advanced) — One Aggregate holds a PostgreSQL database and the server that reads it.
  • terraform-declared-sensitivity (advanced) — A declaration that a value carries secret material is authored once, on a Component’s schema.
  • cross-boundary-networking (advanced) — A two-component stack — an Adminer database UI and a PostgreSQL database — split across two boundaries, where Adminer must reach the database across the boundary seam.
  • module-boundary-routing (advanced) — This example compiles two capabilities — a Thanos metrics read tier over object storage and a document database speaking the MongoDB wire protocol — from one Developer-authored Aggregate, and places each into a boundary of its own from the Release.
  • annotation-driven-monitoring (advanced) — This example attaches a monitoring Feature to six services across a nested topology without writing a single per-component features: block.
  • policy-in-ci (advanced) — Two ready-to-use rule scripts that read an Aggrega build’s output directory and refuse it when it breaks a rule.
  • policy-payload-leaf-sensitivity (advanced) — This example teaches one house rule and the fact that makes it expressible.
  • policy-data-class-route (advanced) — An estate runs a claims assistant that handles restricted customer data, and a helpdesk assistant that handles none.
  • policy-label-transform (advanced) — Governance plugins label every component this workspace deploys with its owner, the support tier its environment earns, its backup schedule and a short tag, so that no developer types any of them.
  • policy-org-overlay (advanced) — A team’s policy, its organization’s and its pipeline’s run together on one build, each attached in a configuration file of its own.
  • policy-render-verdict (advanced) — One house rule, attached at the render-verdict role, judges the files a build writes for four targets and refuses a violation planted on each.
  • policy-annotation-transform (advanced) — A governance policy gives every component of a shop the platform’s monitoring and an AWS IAM role.
  • ai-gateway-own-webhook-certificate (advanced) — This is an advanced example.

Importers

Tier importers: a project written in another format, drafted into Aggrega files by aggrega import, then reviewed and built.

  • import-compose (start) — A Compose file running an API, the PostgreSQL database it keeps its notes in and a Redis cache, drafted into Aggrega files by aggrega import — the connections, the database’s settings, the password as a variable reference and each image’s tag carried over — and built for Docker Compose.
  • import-mcp (start) — A Claude Code .mcp.json listing three Model Context Protocol servers — two started from a command line and one someone else runs — drafted into Aggrega files by aggrega import, each server mapped to the realization of how it runs, and built for Kubernetes.
  • import-n8n (start) — An n8n workflow — a chat trigger, an AI Agent, an OpenAI Chat Model and a Simple Memory — imported by aggrega import into an Aggregate, a Release and a Manifest that build for Docker Compose as written.
  • import-flowise (start) — A Flowise chatflow — a ChatOpenAI node, a Buffer Memory and a Conversation Chain — imported by aggrega import into an Aggregate, a Release and a Manifest that build for Docker Compose as written.
  • import-langflow (start) — Langflow’s Basic Prompting starter project, exported as JSON, imported by aggrega import into an Aggregate, a Release and a Manifest that build for Docker Compose as written.
  • import-dify (start) — A Dify chat application, exported in Dify’s DSL, imported by aggrega import into an Aggregate, a Release and a Manifest that build the standard library’s Dify installation, carrying it, for Kubernetes as written.
  • import-google-adk (start) — The Agent Config of an application built on Google’s Agent Development Kit — one agent on Gemini, with the Google Search tool ADK ships — drafted into Aggrega files by aggrega import, with the application’s image answered once in an answers file, and built for Docker Compose.
  • import-langgraph (start) — The langgraph.json of a LangGraph application — one graph, keeping its state in PostgreSQL — drafted into Aggrega files by aggrega import, with the model the graph calls and the application’s image answered once in an answers file, and built for Docker Compose.
  • import-crewai (start) — The agent and task declarations of a CrewAI project in the classic layout — two agents on one OpenAI model, one task each — drafted into Aggrega files by aggrega import, with the image the crew’s program runs in answered once in an answers file, and built for Docker Compose.
  • import-agent-framework (start) — A declarative agent of Microsoft Agent Framework — one agent on an OpenAI model, searching documentation through an MCP server — drafted into Aggrega files by aggrega import, with the application’s image answered once in an answers file, and built for Docker Compose.

By product

core/ai-agent/agent-framework

  • import-agent-framework (start) — A declarative agent of Microsoft Agent Framework — one agent on an OpenAI model, searching documentation through an MCP server — drafted into Aggrega files by aggrega import, with the application’s image answered once in an answers file, and built for Docker Compose.

core/ai-agent/crewai

  • envoy-ai-gateway-token-budget (start) — A team puts OpenAI’s gpt-4o-mini behind an in-cluster gateway, wants a ceiling on the tokens the gateway spends on it each calendar month, and points its agent at the gateway rather than at OpenAI.
  • import-crewai (start) — The agent and task declarations of a CrewAI project in the classic layout — two agents on one OpenAI model, one task each — drafted into Aggrega files by aggrega import, with the image the crew’s program runs in answered once in an answers file, and built for Docker Compose.
  • model-api-key-sharing (start) — Two CrewAI agents behind one OpenAI-compatible gateway.

core/ai-agent/dify

  • import-dify (start) — A Dify chat application, exported in Dify’s DSL, imported by aggrega import into an Aggregate, a Release and a Manifest that build the standard library’s Dify installation, carrying it, for Kubernetes as written.

core/ai-agent/dify-plugin-daemon

  • import-dify (start) — A Dify chat application, exported in Dify’s DSL, imported by aggrega import into an Aggregate, a Release and a Manifest that build the standard library’s Dify installation, carrying it, for Kubernetes as written.

core/ai-agent/dify-sandbox

  • import-dify (start) — A Dify chat application, exported in Dify’s DSL, imported by aggrega import into an Aggregate, a Release and a Manifest that build the standard library’s Dify installation, carrying it, for Kubernetes as written.

core/ai-agent/dify-ssrf-proxy

  • import-dify (start) — A Dify chat application, exported in Dify’s DSL, imported by aggrega import into an Aggregate, a Release and a Manifest that build the standard library’s Dify installation, carrying it, for Kubernetes as written.

core/ai-agent/dify-web

  • import-dify (start) — A Dify chat application, exported in Dify’s DSL, imported by aggrega import into an Aggregate, a Release and a Manifest that build the standard library’s Dify installation, carrying it, for Kubernetes as written.

core/ai-agent/dify-worker

  • import-dify (start) — A Dify chat application, exported in Dify’s DSL, imported by aggrega import into an Aggregate, a Release and a Manifest that build the standard library’s Dify installation, carrying it, for Kubernetes as written.

core/ai-agent/dify-worker-beat

  • import-dify (start) — A Dify chat application, exported in Dify’s DSL, imported by aggrega import into an Aggregate, a Release and a Manifest that build the standard library’s Dify installation, carrying it, for Kubernetes as written.

core/ai-agent/flowise

  • import-flowise (start) — A Flowise chatflow — a ChatOpenAI node, a Buffer Memory and a Conversation Chain — imported by aggrega import into an Aggregate, a Release and a Manifest that build for Docker Compose as written.

core/ai-agent/google-adk

  • import-google-adk (start) — The Agent Config of an application built on Google’s Agent Development Kit — one agent on Gemini, with the Google Search tool ADK ships — drafted into Aggrega files by aggrega import, with the application’s image answered once in an answers file, and built for Docker Compose.

core/ai-agent/langflow

  • import-langflow (start) — Langflow’s Basic Prompting starter project, exported as JSON, imported by aggrega import into an Aggregate, a Release and a Manifest that build for Docker Compose as written.

core/ai-agent/langgraph

  • ai-agent-and-model-router (start) — An agent application that reaches two upstream provider models through one in-cluster router, compiled to Kubernetes manifests.
  • import-langgraph (start) — The langgraph.json of a LangGraph application — one graph, keeping its state in PostgreSQL — drafted into Aggrega files by aggrega import, with the model the graph calls and the application’s image answered once in an answers file, and built for Docker Compose.
  • nemo-guardrails-nemoguard-nims (start) — An agent’s model requests pass through NVIDIA NeMo Guardrails, which checks each one with two of NVIDIA’s NemoGuard models, licensed NVIDIA products that need a licence from NVIDIA, an NGC API key and a GPU node to run.
  • policy-data-class-route (advanced) — An estate runs a claims assistant that handles restricted customer data, and a helpdesk assistant that handles none.
  • quickstart-ai (start) — A small LangGraph agent, grown in four steps: it starts on a local model with a memory, gains a cloud model with the local one as its fallback, gets guardrails in front of both, and finally builds for Kubernetes.

core/ai-agent/n8n

  • import-n8n (start) — An n8n workflow — a chat trigger, an AI Agent, an OpenAI Chat Model and a Simple Memory — imported by aggrega import into an Aggregate, a Release and a Manifest that build for Docker Compose as written.

core/ai-model/anthropic

  • adhoc-uses-socket (start) — This example teaches one line, and both halves of it.

core/ai-model/gemini

  • import-google-adk (start) — The Agent Config of an application built on Google’s Agent Development Kit — one agent on Gemini, with the Google Search tool ADK ships — drafted into Aggrega files by aggrega import, with the application’s image answered once in an answers file, and built for Docker Compose.

core/ai-model/nemoguard-content-safety

  • nemo-guardrails-nemoguard-nims (start) — An agent’s model requests pass through NVIDIA NeMo Guardrails, which checks each one with two of NVIDIA’s NemoGuard models, licensed NVIDIA products that need a licence from NVIDIA, an NGC API key and a GPU node to run.

core/ai-model/ollama

  • model-server-caller-allowlist (start) — A model server running in a cluster answers whoever reaches its address.
  • quickstart-ai (start) — A small LangGraph agent, grown in four steps: it starts on a local model with a memory, gains a cloud model with the local one as its fallback, gets guardrails in front of both, and finally builds for Kubernetes.

core/ai-model/openai

  • ai-gateway-log-masking (start) — A support assistant has to work with customers’ names and email addresses, so the model it calls must see them.
  • ai-gateway-semantic-cache (start) — A support assistant is asked the same questions all day in slightly different words.
  • apisix-token-budget (start) — A team puts two OpenAI models behind one gateway and wants a ceiling on what the gateway spends on them each day, counted in tokens.
  • connection-credentials (start) — A semantic-memory store reaching two models and presenting a different key to each, compiled to Kubernetes manifests.
  • envoy-ai-gateway-token-budget (start) — A team puts OpenAI’s gpt-4o-mini behind an in-cluster gateway, wants a ceiling on the tokens the gateway spends on it each calendar month, and points its agent at the gateway rather than at OpenAI.
  • import-agent-framework (start) — A declarative agent of Microsoft Agent Framework — one agent on an OpenAI model, searching documentation through an MCP server — drafted into Aggrega files by aggrega import, with the application’s image answered once in an answers file, and built for Docker Compose.
  • import-crewai (start) — The agent and task declarations of a CrewAI project in the classic layout — two agents on one OpenAI model, one task each — drafted into Aggrega files by aggrega import, with the image the crew’s program runs in answered once in an answers file, and built for Docker Compose.
  • import-flowise (start) — A Flowise chatflow — a ChatOpenAI node, a Buffer Memory and a Conversation Chain — imported by aggrega import into an Aggregate, a Release and a Manifest that build for Docker Compose as written.
  • import-langflow (start) — Langflow’s Basic Prompting starter project, exported as JSON, imported by aggrega import into an Aggregate, a Release and a Manifest that build for Docker Compose as written.
  • import-langgraph (start) — The langgraph.json of a LangGraph application — one graph, keeping its state in PostgreSQL — drafted into Aggrega files by aggrega import, with the model the graph calls and the application’s image answered once in an answers file, and built for Docker Compose.
  • import-n8n (start) — An n8n workflow — a chat trigger, an AI Agent, an OpenAI Chat Model and a Simple Memory — imported by aggrega import into an Aggregate, a Release and a Manifest that build for Docker Compose as written.
  • policy-data-class-route (advanced) — An estate runs a claims assistant that handles restricted customer data, and a helpdesk assistant that handles none.
  • quickstart-ai (start) — A small LangGraph agent, grown in four steps: it starts on a local model with a memory, gains a cloud model with the local one as its fallback, gets guardrails in front of both, and finally builds for Kubernetes.

core/ai-model/openai-compatible

core/ai-model/openai-embedding

core/ai-model/tei

  • connection-credentials (start) — A semantic-memory store reaching two models and presenting a different key to each, compiled to Kubernetes manifests.

core/ai-tool/mcp

  • import-mcp (start) — A Claude Code .mcp.json listing three Model Context Protocol servers — two started from a command line and one someone else runs — drafted into Aggrega files by aggrega import, each server mapped to the realization of how it runs, and built for Kubernetes.
  • mcp-address-from-secret (authoring) — Some Model Context Protocol servers that someone else runs read their key from their own address — https://mcp.example.com/mcp?api_key=<key> — rather than from a request header.

core/compute/server

  • quickstart-ai (start) — A small LangGraph agent, grown in four steps: it starts on a local model with a memory, gains a cloud model with the local one as its fallback, gets guardrails in front of both, and finally builds for Kubernetes.

core/datastore/cognee

  • connection-credentials (start) — A semantic-memory store reaching two models and presenting a different key to each, compiled to Kubernetes manifests.

core/datastore/documentdb

  • ferretdb-stack (start) — This example compiles a small, real stack — a document database exposing the MongoDB wire protocol — to synthesized Kubernetes manifests from one Developer-authored Aggregate.
  • module-boundary-routing (advanced) — This example compiles two capabilities — a Thanos metrics read tier over object storage and a document database speaking the MongoDB wire protocol — from one Developer-authored Aggregate, and places each into a boundary of its own from the Release.

core/datastore/etcd

  • apisix-stack (start) — This example compiles a small, real stack — a dynamic API gateway — to synthesized Kubernetes manifests from one Developer-authored Aggregate.

core/datastore/ferretdb

  • ferretdb-stack (start) — This example compiles a small, real stack — a document database exposing the MongoDB wire protocol — to synthesized Kubernetes manifests from one Developer-authored Aggregate.
  • module-boundary-routing (advanced) — This example compiles two capabilities — a Thanos metrics read tier over object storage and a document database speaking the MongoDB wire protocol — from one Developer-authored Aggregate, and places each into a boundary of its own from the Release.

core/datastore/mariadb

  • adhoc-uses-socket (start) — This example teaches one line, and both halves of it.
  • advanced-platform (advanced) — A multi-boundary Kubernetes platform that combines several mechanisms in one build from a single Developer-authored Aggregate: boundary-scope FeatureRecipes, parameter hoisting, the credential subsystem, and cross-boundary references resolving through Service DNS.
  • catalog-only (start) — This example deploys a small, real stack — a MariaDB database with an Adminer web UI in front of it — by referencing standard-library catalog entities only.
  • cloudformation-rds-stack (advanced) — A managed database and the application that reads it, authored once as developer intent and assembled into AWS CloudFormation stack templates.
  • mariadb-adminer (authoring) — This example compiles a small, real stack — a MariaDB database with an Adminer web UI in front of it — from a single Developer-authored Aggregate to two platforms.
  • mariadb-bitnami-credential-set (authoring) — A single MariaDB database realized by the Bitnami Helm chart, whose passwords are supplied by one multi-key referenceable secret (core/referenced-secret-set).
  • mariadb-helm-synth (start) — A single MariaDB database rendered on Kubernetes by the helm provider’s Workload synthesis — no external chart.
  • policy-label-transform (advanced) — Governance plugins label every component this workspace deploys with its owner, the support tier its environment earns, its backup schedule and a short tag, so that no developer types any of them.
  • policy-org-overlay (advanced) — A team’s policy, its organization’s and its pipeline’s run together on one build, each attached in a configuration file of its own.
  • policy-payload-leaf-sensitivity (advanced) — This example teaches one house rule and the fact that makes it expressible.
  • terraform-rds-module (authoring) — The same MariaDB intent as the terraform-rds example, rendered through the sourced shape of the Terraform provider: instead of an inline HCL body, the Recipe points at a local Terraform module and the compiler vendors it verbatim, then supplies its input variables from the developer and operator pillars.
  • terraform-rds (authoring) — A single MariaDB database authored once as developer intent and rendered to a Terraform HCL file that provisions a managed AWS RDS instance.

core/datastore/memcached

  • memcached-cache (start) — This lean example compiles a single Memcached in-memory cache from one Developer-authored Aggregate to two realizations.

core/datastore/mysql

  • mysql-standalone (start) — This lean example compiles a single MySQL database from Developer-authored Aggregates to two targets.

core/datastore/mysql-innodb-cluster

  • mysql-innodb-cluster (start) — A MySQL InnoDB Cluster and the control plane that reconciles it, built twice from one unchanged Aggregate: once asking for a single server instance, once asking for three.

core/datastore/mysql-operator

  • mysql-innodb-cluster (start) — A MySQL InnoDB Cluster and the control plane that reconciles it, built twice from one unchanged Aggregate: once asking for a single server instance, once asking for three.

core/datastore/postgres

  • aws-rds-and-ecs-service (advanced) — One Aggregate holds a PostgreSQL database and the server that reads it.
  • credential-secretkeyref (start) — A single PostgreSQL database whose password is supplied by the credential subsystem, shown per provider.
  • credential-shape-per-target (authoring) — How a credential reaches a running container is a property of where you deploy, not of the application.
  • cross-boundary-networking (advanced) — A two-component stack — an Adminer database UI and a PostgreSQL database — split across two boundaries, where Adminer must reach the database across the boundary seam.
  • datastore-backup (start) — A PostgreSQL database backed up on Kubernetes through Velero and through CloudNativePG, and on AWS through Amazon RDS’s own automated backups, on Terraform and on CloudFormation, and through AWS Backup, from one core/backup attachment the operator writes in each Release, with the refusal on a target that has no backup product.
  • import-compose (start) — A Compose file running an API, the PostgreSQL database it keeps its notes in and a Redis cache, drafted into Aggrega files by aggrega import — the connections, the database’s settings, the password as a variable reference and each image’s tag carried over — and built for Docker Compose.
  • import-dify (start) — A Dify chat application, exported in Dify’s DSL, imported by aggrega import into an Aggregate, a Release and a Manifest that build the standard library’s Dify installation, carrying it, for Kubernetes as written.
  • import-langgraph (start) — The langgraph.json of a LangGraph application — one graph, keeping its state in PostgreSQL — drafted into Aggrega files by aggrega import, with the model the graph calls and the application’s image answered once in an answers file, and built for Docker Compose.
  • keycloak-stack (start) — This example compiles a small, real stack — a database-backed identity server — to synthesized Kubernetes manifests from one Developer-authored Aggregate.
  • kong-stack (start) — This example compiles a small, real stack — a database-backed API gateway — to synthesized Kubernetes manifests from one Developer-authored Aggregate.
  • policy-render-verdict (advanced) — One house rule, attached at the render-verdict role, judges the files a build writes for four targets and refuses a violation planted on each.
  • postgres-init-config (start) — core/datastore/postgres exposes two optional developer values that shape the database’s first start: init_scripts (SQL or shell run once on initialization) and custom_config (a postgresql.conf fragment).
  • postgres-three-realizations (authoring) — A PostgreSQL database and the application that reads it, deployed three different ways from one unchanged Aggregate: PostgreSQL running in the cluster, PostgreSQL as a managed cloud instance, and a PostgreSQL server that already existed before this Release was deployed.
  • quickstart-web (start) — A small web application that keeps notes in PostgreSQL, grown in four steps: it starts with its database on your machine, gains a Redis cache, moves to AWS with the database on Amazon RDS, and finally gets its backups.

core/datastore/redis

  • ai-gateway-semantic-cache (start) — A support assistant is asked the same questions all day in slightly different words.
  • envoy-ai-gateway-token-budget (start) — A team puts OpenAI’s gpt-4o-mini behind an in-cluster gateway, wants a ceiling on the tokens the gateway spends on it each calendar month, and points its agent at the gateway rather than at OpenAI.
  • import-compose (start) — A Compose file running an API, the PostgreSQL database it keeps its notes in and a Redis cache, drafted into Aggrega files by aggrega import — the connections, the database’s settings, the password as a variable reference and each image’s tag carried over — and built for Docker Compose.
  • import-dify (start) — A Dify chat application, exported in Dify’s DSL, imported by aggrega import into an Aggregate, a Release and a Manifest that build the standard library’s Dify installation, carrying it, for Kubernetes as written.
  • policy-label-transform (advanced) — Governance plugins label every component this workspace deploys with its owner, the support tier its environment earns, its backup schedule and a short tag, so that no developer types any of them.
  • quickstart-web (start) — A small web application that keeps notes in PostgreSQL, grown in four steps: it starts with its database on your machine, gains a Redis cache, moves to AWS with the database on Amazon RDS, and finally gets its backups.
  • redis-cache (start) — This lean example compiles a single Redis in-memory cache (Redis wire protocol) from one Developer-authored Aggregate to two realizations.

core/datastore/valkey

  • ai-agent-and-model-router (start) — An agent application that reaches two upstream provider models through one in-cluster router, compiled to Kubernetes manifests.
  • nemo-guardrails-nemoguard-nims (start) — An agent’s model requests pass through NVIDIA NeMo Guardrails, which checks each one with two of NVIDIA’s NemoGuard models, licensed NVIDIA products that need a licence from NVIDIA, an NGC API key and a GPU node to run.
  • policy-data-class-route (advanced) — An estate runs a claims assistant that handles restricted customer data, and a helpdesk assistant that handles none.
  • quickstart-ai (start) — A small LangGraph agent, grown in four steps: it starts on a local model with a memory, gains a cloud model with the local one as its fallback, gets guardrails in front of both, and finally builds for Kubernetes.
  • valkey-cache (start) — This lean example compiles a single Valkey in-memory cache (Redis wire protocol) from one Developer-authored Aggregate to two realizations.

core/datastore/weaviate

  • import-dify (start) — A Dify chat application, exported in Dify’s DSL, imported by aggrega import into an Aggregate, a Release and a Manifest that build the standard library’s Dify installation, carrying it, for Kubernetes as written.

core/devtool/adminer

  • adhoc-uses-socket (start) — This example teaches one line, and both halves of it.
  • advanced-platform (advanced) — A multi-boundary Kubernetes platform that combines several mechanisms in one build from a single Developer-authored Aggregate: boundary-scope FeatureRecipes, parameter hoisting, the credential subsystem, and cross-boundary references resolving through Service DNS.
  • catalog-only (start) — This example deploys a small, real stack — a MariaDB database with an Adminer web UI in front of it — by referencing standard-library catalog entities only.
  • cross-boundary-networking (advanced) — A two-component stack — an Adminer database UI and a PostgreSQL database — split across two boundaries, where Adminer must reach the database across the boundary seam.
  • extends-wrapper (authoring) — This example teaches one thing: a Component that extends another inherits that base’s whole data contract, so every Recipe written for the base already implements the extending Component.
  • mariadb-adminer (authoring) — This example compiles a small, real stack — a MariaDB database with an Adminer web UI in front of it — from a single Developer-authored Aggregate to two platforms.
  • nginx-gateway (start) — This example compiles a small, real stack — an NGINX reverse-proxy gateway fronting a web backend — from one Developer-authored Aggregate to two targets.
  • policy-label-transform (advanced) — Governance plugins label every component this workspace deploys with its owner, the support tier its environment earns, its backup schedule and a short tag, so that no developer types any of them.
  • policy-org-overlay (advanced) — A team’s policy, its organization’s and its pipeline’s run together on one build, each attached in a configuration file of its own.

core/devtool/harbor

  • harbor-stack (start) — This example compiles a real container registry to Kubernetes manifests from one Developer-authored Aggregate.

core/gateway/apisix

  • apisix-stack (start) — This example compiles a small, real stack — a dynamic API gateway — to synthesized Kubernetes manifests from one Developer-authored Aggregate.
  • apisix-token-budget (start) — A team puts two OpenAI models behind one gateway and wants a ceiling on what the gateway spends on them each day, counted in tokens.

core/gateway/contour

  • contour-gateway (start) — This example compiles a small, real stack — a Contour ingress gateway — from one Developer-authored Aggregate to Kubernetes.

core/gateway/envoy-ai-gateway-operator

  • ai-gateway-own-webhook-certificate (advanced) — This is an advanced example.
  • envoy-ai-gateway-token-budget (start) — A team puts OpenAI’s gpt-4o-mini behind an in-cluster gateway, wants a ceiling on the tokens the gateway spends on it each calendar month, and points its agent at the gateway rather than at OpenAI.

core/gateway/envoy-gateway

  • envoy-ai-gateway-token-budget (start) — A team puts OpenAI’s gpt-4o-mini behind an in-cluster gateway, wants a ceiling on the tokens the gateway spends on it each calendar month, and points its agent at the gateway rather than at OpenAI.

core/gateway/kong

  • kong-stack (start) — This example compiles a small, real stack — a database-backed API gateway — to synthesized Kubernetes manifests from one Developer-authored Aggregate.

core/gateway/litellm

  • ai-agent-and-model-router (start) — An agent application that reaches two upstream provider models through one in-cluster router, compiled to Kubernetes manifests.
  • ai-gateway-log-masking (start) — A support assistant has to work with customers’ names and email addresses, so the model it calls must see them.
  • ai-gateway-prompt-injection-shield (start) — A support assistant’s users can type anything, and some of what they type tries to make the model ignore the instructions it was given.
  • ai-gateway-semantic-cache (start) — A support assistant is asked the same questions all day in slightly different words.
  • nemo-guardrails-nemoguard-nims (start) — An agent’s model requests pass through NVIDIA NeMo Guardrails, which checks each one with two of NVIDIA’s NemoGuard models, licensed NVIDIA products that need a licence from NVIDIA, an NGC API key and a GPU node to run.
  • policy-data-class-route (advanced) — An estate runs a claims assistant that handles restricted customer data, and a helpdesk assistant that handles none.
  • quickstart-ai (start) — A small LangGraph agent, grown in four steps: it starts on a local model with a memory, gains a cloud model with the local one as its fallback, gets guardrails in front of both, and finally builds for Kubernetes.

core/gateway/nginx

  • extends-wrapper (authoring) — This example teaches one thing: a Component that extends another inherits that base’s whole data contract, so every Recipe written for the base already implements the extending Component.
  • model-server-caller-allowlist (start) — A model server running in a cluster answers whoever reaches its address.
  • nginx-gateway (start) — This example compiles a small, real stack — an NGINX reverse-proxy gateway fronting a web backend — from one Developer-authored Aggregate to two targets.

core/messaging/kafka

  • kafka-broker (start) — This example compiles a small, real stack — an Apache Kafka event-streaming broker in its single-node KRaft shape — from one Developer-authored Aggregate to Kubernetes, synthesized directly from the official Apache Kafka image with no upstream chart.

core/messaging/nats

  • nats-messaging (start) — This example compiles a single NATS messaging server (pub-sub, request-reply, queueing) from one Developer-authored Aggregate to two realizations.

core/messaging/rabbitmq

  • rabbitmq-broker (start) — This example compiles a single RabbitMQ message broker (AMQP) from one Developer-authored Aggregate to two targets.

core/observability/fluent-bit

  • fluent-bit-to-fluentd (start) — This example compiles a real log pipeline — a Fluent Bit forwarder shipping records to a Fluentd aggregator over the forward protocol — from one Developer-authored Aggregate to two realizations.

core/observability/fluentd

  • fluent-bit-to-fluentd (start) — This example compiles a real log pipeline — a Fluent Bit forwarder shipping records to a Fluentd aggregator over the forward protocol — from one Developer-authored Aggregate to two realizations.
  • fluentd-aggregator (start) — This example compiles a Fluentd log aggregator — the receiving end of a log pipeline — from one Developer-authored Aggregate to two realizations.

core/observability/grafana

  • grafana-dashboards (start) — This example compiles a single Grafana dashboards and visualization server from one Developer-authored Aggregate to two realizations.
  • prometheus-scrape (start) — This example compiles a small, real stack — a Prometheus metrics server scraping two Grafana dashboards servers — from one Developer-authored Aggregate to two targets.

core/observability/jaeger

  • jaeger-tracing (start) — This example compiles a small, real stack — a Jaeger distributed-tracing backend in its single-node shape — from one Developer-authored Aggregate to Kubernetes, synthesized directly from the official Jaeger image with no upstream chart.

core/observability/loki

  • loki-logging (start) — This example compiles a small, real stack — a Grafana Loki log-aggregation server — from one Developer-authored Aggregate to Kubernetes, backed by the official Grafana Loki Helm chart in its single-binary shape.

core/observability/prometheus

  • prometheus-scrape (start) — This example compiles a small, real stack — a Prometheus metrics server scraping two Grafana dashboards servers — from one Developer-authored Aggregate to two targets.

core/observability/tempo

  • tempo-tracing (start) — This example compiles a small, real stack — a Grafana Tempo distributed-tracing server — from one Developer-authored Aggregate to Kubernetes via Workload synthesis on the official grafana/tempo image, in its single-binary shape.

core/observability/thanos-query

  • module-boundary-routing (advanced) — This example compiles two capabilities — a Thanos metrics read tier over object storage and a document database speaking the MongoDB wire protocol — from one Developer-authored Aggregate, and places each into a boundary of its own from the Release.
  • thanos-stack (start) — This example compiles a small, real stack — the read/query tier of a Thanos metrics system — to synthesized Kubernetes manifests from one Developer-authored Aggregate.

core/observability/thanos-store

  • module-boundary-routing (advanced) — This example compiles two capabilities — a Thanos metrics read tier over object storage and a document database speaking the MongoDB wire protocol — from one Developer-authored Aggregate, and places each into a boundary of its own from the Release.
  • thanos-stack (start) — This example compiles a small, real stack — the read/query tier of a Thanos metrics system — to synthesized Kubernetes manifests from one Developer-authored Aggregate.

core/security/cert-manager

  • cert-manager-tls (start) — This example compiles a small, real stack — a cert-manager certificate controller — from one Developer-authored Aggregate to Kubernetes.
  • envoy-ai-gateway-token-budget (start) — A team puts OpenAI’s gpt-4o-mini behind an in-cluster gateway, wants a ceiling on the tokens the gateway spends on it each calendar month, and points its agent at the gateway rather than at OpenAI.

core/security/external-secrets

  • external-secrets-operator (start) — This example compiles a small, real stack — the external-secrets operator — from one Developer-authored Aggregate to Kubernetes, backed by the official external-secrets Helm chart.

core/security/keycloak

  • keycloak-stack (start) — This example compiles a small, real stack — a database-backed identity server — to synthesized Kubernetes manifests from one Developer-authored Aggregate.

core/security/nemo-guardrails

  • ai-gateway-prompt-injection-shield (start) — A support assistant’s users can type anything, and some of what they type tries to make the model ignore the instructions it was given.
  • nemo-guardrails-nemoguard-nims (start) — An agent’s model requests pass through NVIDIA NeMo Guardrails, which checks each one with two of NVIDIA’s NemoGuard models, licensed NVIDIA products that need a licence from NVIDIA, an NGC API key and a GPU node to run.

core/security/nemoguard-jailbreak-detect

  • nemo-guardrails-nemoguard-nims (start) — An agent’s model requests pass through NVIDIA NeMo Guardrails, which checks each one with two of NVIDIA’s NemoGuard models, licensed NVIDIA products that need a licence from NVIDIA, an NGC API key and a GPU node to run.

core/security/openbao

  • openbao-secrets (start) — This example compiles a small, real stack — a single OpenBao secrets server — from one Developer-authored Aggregate to Kubernetes, backed by the official OpenBao Helm chart.

core/security/presidio-analyzer

  • ai-gateway-log-masking (start) — A support assistant has to work with customers’ names and email addresses, so the model it calls must see them.
  • policy-data-class-route (advanced) — An estate runs a claims assistant that handles restricted customer data, and a helpdesk assistant that handles none.
  • quickstart-ai (start) — A small LangGraph agent, grown in four steps: it starts on a local model with a memory, gains a cloud model with the local one as its fallback, gets guardrails in front of both, and finally builds for Kubernetes.

core/security/presidio-anonymizer

  • ai-gateway-log-masking (start) — A support assistant has to work with customers’ names and email addresses, so the model it calls must see them.
  • policy-data-class-route (advanced) — An estate runs a claims assistant that handles restricted customer data, and a helpdesk assistant that handles none.
  • quickstart-ai (start) — A small LangGraph agent, grown in four steps: it starts on a local model with a memory, gains a cloud model with the local one as its fallback, gets guardrails in front of both, and finally builds for Kubernetes.

core/security/sealed-secrets

  • sealed-secrets-controller (start) — This example compiles a small, real stack — the sealed-secrets controller — from one Developer-authored Aggregate to Kubernetes, backed by the official sealed-secrets Helm chart served from an HTTPS chart repository.

core/security/trustyai-huggingface-detector

  • ai-gateway-prompt-injection-shield (start) — A support assistant’s users can type anything, and some of what they type tries to make the model ignore the instructions it was given.
  • nemo-guardrails-nemoguard-nims (start) — An agent’s model requests pass through NVIDIA NeMo Guardrails, which checks each one with two of NVIDIA’s NemoGuard models, licensed NVIDIA products that need a licence from NVIDIA, an NGC API key and a GPU node to run.

core/storage/barman-cloud-plugin

  • datastore-backup (start) — A PostgreSQL database backed up on Kubernetes through Velero and through CloudNativePG, and on AWS through Amazon RDS’s own automated backups, on Terraform and on CloudFormation, and through AWS Backup, from one core/backup attachment the operator writes in each Release, with the refusal on a target that has no backup product.

core/storage/s3-object-store

  • datastore-backup (start) — A PostgreSQL database backed up on Kubernetes through Velero and through CloudNativePG, and on AWS through Amazon RDS’s own automated backups, on Terraform and on CloudFormation, and through AWS Backup, from one core/backup attachment the operator writes in each Release, with the refusal on a target that has no backup product.
  • module-boundary-routing (advanced) — This example compiles two capabilities — a Thanos metrics read tier over object storage and a document database speaking the MongoDB wire protocol — from one Developer-authored Aggregate, and places each into a boundary of its own from the Release.
  • s3-object-store (start) — This example compiles one S3-compatible object store, the core/storage/s3-object-store component, to its two self-hosted realizations.
  • thanos-stack (start) — This example compiles a small, real stack — the read/query tier of a Thanos metrics system — to synthesized Kubernetes manifests from one Developer-authored Aggregate.

core/storage/velero

  • datastore-backup (start) — A PostgreSQL database backed up on Kubernetes through Velero and through CloudNativePG, and on AWS through Amazon RDS’s own automated backups, on Terraform and on CloudFormation, and through AWS Backup, from one core/backup attachment the operator writes in each Release, with the refusal on a target that has no backup product.

By capability

multi-target

one Aggregate built for two or more targets, or realized two or more ways.

  • aws-rds-and-ecs-service (advanced) — One Aggregate holds a PostgreSQL database and the server that reads it.
  • credential-secretkeyref (start) — A single PostgreSQL database whose password is supplied by the credential subsystem, shown per provider.
  • credential-shape-per-target (authoring) — How a credential reaches a running container is a property of where you deploy, not of the application.
  • cross-boundary-networking (advanced) — A two-component stack — an Adminer database UI and a PostgreSQL database — split across two boundaries, where Adminer must reach the database across the boundary seam.
  • datastore-backup (start) — A PostgreSQL database backed up on Kubernetes through Velero and through CloudNativePG, and on AWS through Amazon RDS’s own automated backups, on Terraform and on CloudFormation, and through AWS Backup, from one core/backup attachment the operator writes in each Release, with the refusal on a target that has no backup product.
  • fluent-bit-to-fluentd (start) — This example compiles a real log pipeline — a Fluent Bit forwarder shipping records to a Fluentd aggregator over the forward protocol — from one Developer-authored Aggregate to two realizations.
  • fluentd-aggregator (start) — This example compiles a Fluentd log aggregator — the receiving end of a log pipeline — from one Developer-authored Aggregate to two realizations.
  • grafana-dashboards (start) — This example compiles a single Grafana dashboards and visualization server from one Developer-authored Aggregate to two realizations.
  • mariadb-adminer (authoring) — This example compiles a small, real stack — a MariaDB database with an Adminer web UI in front of it — from a single Developer-authored Aggregate to two platforms.
  • mcp-address-from-secret (authoring) — Some Model Context Protocol servers that someone else runs read their key from their own address — https://mcp.example.com/mcp?api_key=<key> — rather than from a request header.
  • memcached-cache (start) — This lean example compiles a single Memcached in-memory cache from one Developer-authored Aggregate to two realizations.
  • mysql-standalone (start) — This lean example compiles a single MySQL database from Developer-authored Aggregates to two targets.
  • nats-messaging (start) — This example compiles a single NATS messaging server (pub-sub, request-reply, queueing) from one Developer-authored Aggregate to two realizations.
  • nginx-gateway (start) — This example compiles a small, real stack — an NGINX reverse-proxy gateway fronting a web backend — from one Developer-authored Aggregate to two targets.
  • policy-render-verdict (advanced) — One house rule, attached at the render-verdict role, judges the files a build writes for four targets and refuses a violation planted on each.
  • postgres-three-realizations (authoring) — A PostgreSQL database and the application that reads it, deployed three different ways from one unchanged Aggregate: PostgreSQL running in the cluster, PostgreSQL as a managed cloud instance, and a PostgreSQL server that already existed before this Release was deployed.
  • prometheus-scrape (start) — This example compiles a small, real stack — a Prometheus metrics server scraping two Grafana dashboards servers — from one Developer-authored Aggregate to two targets.
  • rabbitmq-broker (start) — This example compiles a single RabbitMQ message broker (AMQP) from one Developer-authored Aggregate to two targets.
  • redis-cache (start) — This lean example compiles a single Redis in-memory cache (Redis wire protocol) from one Developer-authored Aggregate to two realizations.
  • s3-object-store (start) — This example compiles one S3-compatible object store, the core/storage/s3-object-store component, to its two self-hosted realizations.
  • task-run-on-demand (start) — A task carrying core/manual-trigger, deployed without starting on Kubernetes, Docker Compose, Terraform and CloudFormation, beside a task carrying nothing, with the command that starts a run on each target.
  • valkey-cache (start) — This lean example compiles a single Valkey in-memory cache (Redis wire protocol) from one Developer-authored Aggregate to two realizations.

recipe-selection

the Manifest choosing which Recipe realizes a component, or which FeatureRecipe realizes an attachment: per type, per instance or per target.

  • credential-shape-per-target (authoring) — How a credential reaches a running container is a property of where you deploy, not of the application.
  • datastore-backup (start) — A PostgreSQL database backed up on Kubernetes through Velero and through CloudNativePG, and on AWS through Amazon RDS’s own automated backups, on Terraform and on CloudFormation, and through AWS Backup, from one core/backup attachment the operator writes in each Release, with the refusal on a target that has no backup product.
  • import-agent-framework (start) — A declarative agent of Microsoft Agent Framework — one agent on an OpenAI model, searching documentation through an MCP server — drafted into Aggrega files by aggrega import, with the application’s image answered once in an answers file, and built for Docker Compose.
  • import-dify (start) — A Dify chat application, exported in Dify’s DSL, imported by aggrega import into an Aggregate, a Release and a Manifest that build the standard library’s Dify installation, carrying it, for Kubernetes as written.
  • import-mcp (start) — A Claude Code .mcp.json listing three Model Context Protocol servers — two started from a command line and one someone else runs — drafted into Aggrega files by aggrega import, each server mapped to the realization of how it runs, and built for Kubernetes.
  • per-instance-recipe-override (authoring) — This example teaches one Manifest feature: the name mapping tier, which overrides the Recipe for a single component instance while every other instance of the same type keeps the bulk type-tier Recipe.
  • postgres-three-realizations (authoring) — A PostgreSQL database and the application that reads it, deployed three different ways from one unchanged Aggregate: PostgreSQL running in the cluster, PostgreSQL as a managed cloud instance, and a PostgreSQL server that already existed before this Release was deployed.

modules

a catalog Aggregate imported as a module.

  • apisix-stack (start) — This example compiles a small, real stack — a dynamic API gateway — to synthesized Kubernetes manifests from one Developer-authored Aggregate.
  • ferretdb-stack (start) — This example compiles a small, real stack — a document database exposing the MongoDB wire protocol — to synthesized Kubernetes manifests from one Developer-authored Aggregate.
  • harbor-stack (start) — This example compiles a real container registry to Kubernetes manifests from one Developer-authored Aggregate.
  • import-dify (start) — A Dify chat application, exported in Dify’s DSL, imported by aggrega import into an Aggregate, a Release and a Manifest that build the standard library’s Dify installation, carrying it, for Kubernetes as written.
  • keycloak-stack (start) — This example compiles a small, real stack — a database-backed identity server — to synthesized Kubernetes manifests from one Developer-authored Aggregate.
  • kong-stack (start) — This example compiles a small, real stack — a database-backed API gateway — to synthesized Kubernetes manifests from one Developer-authored Aggregate.
  • module-boundary-routing (advanced) — This example compiles two capabilities — a Thanos metrics read tier over object storage and a document database speaking the MongoDB wire protocol — from one Developer-authored Aggregate, and places each into a boundary of its own from the Release.
  • thanos-stack (start) — This example compiles a small, real stack — the read/query tier of a Thanos metrics system — to synthesized Kubernetes manifests from one Developer-authored Aggregate.

connections

components wired through uses sockets, with values piped across each edge.

  • adhoc-uses-socket (start) — This example teaches one line, and both halves of it.
  • ai-agent-and-model-router (start) — An agent application that reaches two upstream provider models through one in-cluster router, compiled to Kubernetes manifests.
  • ai-gateway-log-masking (start) — A support assistant has to work with customers’ names and email addresses, so the model it calls must see them.
  • ai-gateway-prompt-injection-shield (start) — A support assistant’s users can type anything, and some of what they type tries to make the model ignore the instructions it was given.
  • ai-gateway-semantic-cache (start) — A support assistant is asked the same questions all day in slightly different words.
  • apisix-token-budget (start) — A team puts two OpenAI models behind one gateway and wants a ceiling on what the gateway spends on them each day, counted in tokens.
  • aws-rds-and-ecs-service (advanced) — One Aggregate holds a PostgreSQL database and the server that reads it.
  • catalog-only (start) — This example deploys a small, real stack — a MariaDB database with an Adminer web UI in front of it — by referencing standard-library catalog entities only.
  • connection-credentials (start) — A semantic-memory store reaching two models and presenting a different key to each, compiled to Kubernetes manifests.
  • cross-boundary-networking (advanced) — A two-component stack — an Adminer database UI and a PostgreSQL database — split across two boundaries, where Adminer must reach the database across the boundary seam.
  • datastore-backup (start) — A PostgreSQL database backed up on Kubernetes through Velero and through CloudNativePG, and on AWS through Amazon RDS’s own automated backups, on Terraform and on CloudFormation, and through AWS Backup, from one core/backup attachment the operator writes in each Release, with the refusal on a target that has no backup product.
  • envoy-ai-gateway-token-budget (start) — A team puts OpenAI’s gpt-4o-mini behind an in-cluster gateway, wants a ceiling on the tokens the gateway spends on it each calendar month, and points its agent at the gateway rather than at OpenAI.
  • fluent-bit-to-fluentd (start) — This example compiles a real log pipeline — a Fluent Bit forwarder shipping records to a Fluentd aggregator over the forward protocol — from one Developer-authored Aggregate to two realizations.
  • import-agent-framework (start) — A declarative agent of Microsoft Agent Framework — one agent on an OpenAI model, searching documentation through an MCP server — drafted into Aggrega files by aggrega import, with the application’s image answered once in an answers file, and built for Docker Compose.
  • import-compose (start) — A Compose file running an API, the PostgreSQL database it keeps its notes in and a Redis cache, drafted into Aggrega files by aggrega import — the connections, the database’s settings, the password as a variable reference and each image’s tag carried over — and built for Docker Compose.
  • import-crewai (start) — The agent and task declarations of a CrewAI project in the classic layout — two agents on one OpenAI model, one task each — drafted into Aggrega files by aggrega import, with the image the crew’s program runs in answered once in an answers file, and built for Docker Compose.
  • import-flowise (start) — A Flowise chatflow — a ChatOpenAI node, a Buffer Memory and a Conversation Chain — imported by aggrega import into an Aggregate, a Release and a Manifest that build for Docker Compose as written.
  • import-google-adk (start) — The Agent Config of an application built on Google’s Agent Development Kit — one agent on Gemini, with the Google Search tool ADK ships — drafted into Aggrega files by aggrega import, with the application’s image answered once in an answers file, and built for Docker Compose.
  • import-langflow (start) — Langflow’s Basic Prompting starter project, exported as JSON, imported by aggrega import into an Aggregate, a Release and a Manifest that build for Docker Compose as written.
  • import-langgraph (start) — The langgraph.json of a LangGraph application — one graph, keeping its state in PostgreSQL — drafted into Aggrega files by aggrega import, with the model the graph calls and the application’s image answered once in an answers file, and built for Docker Compose.
  • import-n8n (start) — An n8n workflow — a chat trigger, an AI Agent, an OpenAI Chat Model and a Simple Memory — imported by aggrega import into an Aggregate, a Release and a Manifest that build for Docker Compose as written.
  • mariadb-adminer (authoring) — This example compiles a small, real stack — a MariaDB database with an Adminer web UI in front of it — from a single Developer-authored Aggregate to two platforms.
  • mcp-address-from-secret (authoring) — Some Model Context Protocol servers that someone else runs read their key from their own address — https://mcp.example.com/mcp?api_key=<key> — rather than from a request header.
  • model-api-key-sharing (start) — Two CrewAI agents behind one OpenAI-compatible gateway.
  • model-server-caller-allowlist (start) — A model server running in a cluster answers whoever reaches its address.
  • nemo-guardrails-nemoguard-nims (start) — An agent’s model requests pass through NVIDIA NeMo Guardrails, which checks each one with two of NVIDIA’s NemoGuard models, licensed NVIDIA products that need a licence from NVIDIA, an NGC API key and a GPU node to run.
  • nginx-gateway (start) — This example compiles a small, real stack — an NGINX reverse-proxy gateway fronting a web backend — from one Developer-authored Aggregate to two targets.
  • policy-data-class-route (advanced) — An estate runs a claims assistant that handles restricted customer data, and a helpdesk assistant that handles none.
  • postgres-three-realizations (authoring) — A PostgreSQL database and the application that reads it, deployed three different ways from one unchanged Aggregate: PostgreSQL running in the cluster, PostgreSQL as a managed cloud instance, and a PostgreSQL server that already existed before this Release was deployed.
  • prometheus-scrape (start) — This example compiles a small, real stack — a Prometheus metrics server scraping two Grafana dashboards servers — from one Developer-authored Aggregate to two targets.
  • quickstart-ai (start) — A small LangGraph agent, grown in four steps: it starts on a local model with a memory, gains a cloud model with the local one as its fallback, gets guardrails in front of both, and finally builds for Kubernetes.
  • quickstart-web (start) — A small web application that keeps notes in PostgreSQL, grown in four steps: it starts with its database on your machine, gains a Redis cache, moves to AWS with the database on Amazon RDS, and finally gets its backups.

credentials

credential attachments and how each target delivers them.

  • advanced-platform (advanced) — A multi-boundary Kubernetes platform that combines several mechanisms in one build from a single Developer-authored Aggregate: boundary-scope FeatureRecipes, parameter hoisting, the credential subsystem, and cross-boundary references resolving through Service DNS.
  • ai-agent-and-model-router (start) — An agent application that reaches two upstream provider models through one in-cluster router, compiled to Kubernetes manifests.
  • apisix-stack (start) — This example compiles a small, real stack — a dynamic API gateway — to synthesized Kubernetes manifests from one Developer-authored Aggregate.
  • catalog-only (start) — This example deploys a small, real stack — a MariaDB database with an Adminer web UI in front of it — by referencing standard-library catalog entities only.
  • connection-credentials (start) — A semantic-memory store reaching two models and presenting a different key to each, compiled to Kubernetes manifests.
  • credential-secretkeyref (start) — A single PostgreSQL database whose password is supplied by the credential subsystem, shown per provider.
  • credential-shape-per-target (authoring) — How a credential reaches a running container is a property of where you deploy, not of the application.
  • grafana-dashboards (start) — This example compiles a single Grafana dashboards and visualization server from one Developer-authored Aggregate to two realizations.
  • harbor-stack (start) — This example compiles a real container registry to Kubernetes manifests from one Developer-authored Aggregate.
  • import-agent-framework (start) — A declarative agent of Microsoft Agent Framework — one agent on an OpenAI model, searching documentation through an MCP server — drafted into Aggrega files by aggrega import, with the application’s image answered once in an answers file, and built for Docker Compose.
  • import-compose (start) — A Compose file running an API, the PostgreSQL database it keeps its notes in and a Redis cache, drafted into Aggrega files by aggrega import — the connections, the database’s settings, the password as a variable reference and each image’s tag carried over — and built for Docker Compose.
  • import-crewai (start) — The agent and task declarations of a CrewAI project in the classic layout — two agents on one OpenAI model, one task each — drafted into Aggrega files by aggrega import, with the image the crew’s program runs in answered once in an answers file, and built for Docker Compose.
  • import-dify (start) — A Dify chat application, exported in Dify’s DSL, imported by aggrega import into an Aggregate, a Release and a Manifest that build the standard library’s Dify installation, carrying it, for Kubernetes as written.
  • import-flowise (start) — A Flowise chatflow — a ChatOpenAI node, a Buffer Memory and a Conversation Chain — imported by aggrega import into an Aggregate, a Release and a Manifest that build for Docker Compose as written.
  • import-google-adk (start) — The Agent Config of an application built on Google’s Agent Development Kit — one agent on Gemini, with the Google Search tool ADK ships — drafted into Aggrega files by aggrega import, with the application’s image answered once in an answers file, and built for Docker Compose.
  • import-langflow (start) — Langflow’s Basic Prompting starter project, exported as JSON, imported by aggrega import into an Aggregate, a Release and a Manifest that build for Docker Compose as written.
  • import-langgraph (start) — The langgraph.json of a LangGraph application — one graph, keeping its state in PostgreSQL — drafted into Aggrega files by aggrega import, with the model the graph calls and the application’s image answered once in an answers file, and built for Docker Compose.
  • import-mcp (start) — A Claude Code .mcp.json listing three Model Context Protocol servers — two started from a command line and one someone else runs — drafted into Aggrega files by aggrega import, each server mapped to the realization of how it runs, and built for Kubernetes.
  • import-n8n (start) — An n8n workflow — a chat trigger, an AI Agent, an OpenAI Chat Model and a Simple Memory — imported by aggrega import into an Aggregate, a Release and a Manifest that build for Docker Compose as written.
  • mariadb-adminer (authoring) — This example compiles a small, real stack — a MariaDB database with an Adminer web UI in front of it — from a single Developer-authored Aggregate to two platforms.
  • mariadb-bitnami-credential-set (authoring) — A single MariaDB database realized by the Bitnami Helm chart, whose passwords are supplied by one multi-key referenceable secret (core/referenced-secret-set).
  • mariadb-helm-synth (start) — A single MariaDB database rendered on Kubernetes by the helm provider’s Workload synthesis — no external chart.
  • mcp-address-from-secret (authoring) — Some Model Context Protocol servers that someone else runs read their key from their own address — https://mcp.example.com/mcp?api_key=<key> — rather than from a request header.
  • memcached-cache (start) — This lean example compiles a single Memcached in-memory cache from one Developer-authored Aggregate to two realizations.
  • model-api-key-sharing (start) — Two CrewAI agents behind one OpenAI-compatible gateway.
  • multikey-secret-synth (authoring) — A single stateless app rendered on Kubernetes by the helm provider’s Workload synthesis — no external chart.
  • mysql-standalone (start) — This lean example compiles a single MySQL database from Developer-authored Aggregates to two targets.
  • nats-messaging (start) — This example compiles a single NATS messaging server (pub-sub, request-reply, queueing) from one Developer-authored Aggregate to two realizations.
  • nemo-guardrails-nemoguard-nims (start) — An agent’s model requests pass through NVIDIA NeMo Guardrails, which checks each one with two of NVIDIA’s NemoGuard models, licensed NVIDIA products that need a licence from NVIDIA, an NGC API key and a GPU node to run.
  • policy-payload-leaf-sensitivity (advanced) — This example teaches one house rule and the fact that makes it expressible.
  • quickstart-ai (start) — A small LangGraph agent, grown in four steps: it starts on a local model with a memory, gains a cloud model with the local one as its fallback, gets guardrails in front of both, and finally builds for Kubernetes.
  • quickstart-web (start) — A small web application that keeps notes in PostgreSQL, grown in four steps: it starts with its database on your machine, gains a Redis cache, moves to AWS with the database on Amazon RDS, and finally gets its backups.
  • rabbitmq-broker (start) — This example compiles a single RabbitMQ message broker (AMQP) from one Developer-authored Aggregate to two targets.
  • redis-cache (start) — This lean example compiles a single Redis in-memory cache (Redis wire protocol) from one Developer-authored Aggregate to two realizations.
  • s3-object-store (start) — This example compiles one S3-compatible object store, the core/storage/s3-object-store component, to its two self-hosted realizations.
  • terraform-rds-module (authoring) — The same MariaDB intent as the terraform-rds example, rendered through the sourced shape of the Terraform provider: instead of an inline HCL body, the Recipe points at a local Terraform module and the compiler vendors it verbatim, then supplies its input variables from the developer and operator pillars.
  • terraform-rds (authoring) — A single MariaDB database authored once as developer intent and rendered to a Terraform HCL file that provisions a managed AWS RDS instance.
  • valkey-cache (start) — This lean example compiles a single Valkey in-memory cache (Redis wire protocol) from one Developer-authored Aggregate to two realizations.

parameters

values hoisted to parameters that a Release fulfils.

  • advanced-platform (advanced) — A multi-boundary Kubernetes platform that combines several mechanisms in one build from a single Developer-authored Aggregate: boundary-scope FeatureRecipes, parameter hoisting, the credential subsystem, and cross-boundary references resolving through Service DNS.
  • ai-agent-and-model-router (start) — An agent application that reaches two upstream provider models through one in-cluster router, compiled to Kubernetes manifests.
  • apisix-stack (start) — This example compiles a small, real stack — a dynamic API gateway — to synthesized Kubernetes manifests from one Developer-authored Aggregate.
  • connection-credentials (start) — A semantic-memory store reaching two models and presenting a different key to each, compiled to Kubernetes manifests.
  • datastore-backup (start) — A PostgreSQL database backed up on Kubernetes through Velero and through CloudNativePG, and on AWS through Amazon RDS’s own automated backups, on Terraform and on CloudFormation, and through AWS Backup, from one core/backup attachment the operator writes in each Release, with the refusal on a target that has no backup product.
  • harbor-stack (start) — This example compiles a real container registry to Kubernetes manifests from one Developer-authored Aggregate.
  • model-api-key-sharing (start) — Two CrewAI agents behind one OpenAI-compatible gateway.
  • task-run-on-demand (start) — A task carrying core/manual-trigger, deployed without starting on Kubernetes, Docker Compose, Terraform and CloudFormation, beside a task carrying nothing, with the command that starts a run on each target.
  • terraform-declared-sensitivity (advanced) — A declaration that a value carries secret material is authored once, on a Component’s schema.

features

Features attached for something other than a credential, such as routing, monitoring, a budget, a cache or masking.

  • advanced-platform (advanced) — A multi-boundary Kubernetes platform that combines several mechanisms in one build from a single Developer-authored Aggregate: boundary-scope FeatureRecipes, parameter hoisting, the credential subsystem, and cross-boundary references resolving through Service DNS.
  • ai-agent-and-model-router (start) — An agent application that reaches two upstream provider models through one in-cluster router, compiled to Kubernetes manifests.
  • ai-gateway-prompt-injection-shield (start) — A support assistant’s users can type anything, and some of what they type tries to make the model ignore the instructions it was given.
  • ai-gateway-semantic-cache (start) — A support assistant is asked the same questions all day in slightly different words.
  • annotation-driven-monitoring (advanced) — This example attaches a monitoring Feature to six services across a nested topology without writing a single per-component features: block.
  • apisix-token-budget (start) — A team puts two OpenAI models behind one gateway and wants a ceiling on what the gateway spends on them each day, counted in tokens.
  • cloudformation-rds-stack (advanced) — A managed database and the application that reads it, authored once as developer intent and assembled into AWS CloudFormation stack templates.
  • datastore-backup (start) — A PostgreSQL database backed up on Kubernetes through Velero and through CloudNativePG, and on AWS through Amazon RDS’s own automated backups, on Terraform and on CloudFormation, and through AWS Backup, from one core/backup attachment the operator writes in each Release, with the refusal on a target that has no backup product.
  • envoy-ai-gateway-token-budget (start) — A team puts OpenAI’s gpt-4o-mini behind an in-cluster gateway, wants a ceiling on the tokens the gateway spends on it each calendar month, and points its agent at the gateway rather than at OpenAI.
  • model-server-caller-allowlist (start) — A model server running in a cluster answers whoever reaches its address.
  • nemo-guardrails-nemoguard-nims (start) — An agent’s model requests pass through NVIDIA NeMo Guardrails, which checks each one with two of NVIDIA’s NemoGuard models, licensed NVIDIA products that need a licence from NVIDIA, an NGC API key and a GPU node to run.
  • policy-annotation-transform (advanced) — A governance policy gives every component of a shop the platform’s monitoring and an AWS IAM role.
  • policy-data-class-route (advanced) — An estate runs a claims assistant that handles restricted customer data, and a helpdesk assistant that handles none.
  • quickstart-ai (start) — A small LangGraph agent, grown in four steps: it starts on a local model with a memory, gains a cloud model with the local one as its fallback, gets guardrails in front of both, and finally builds for Kubernetes.
  • quickstart-web (start) — A small web application that keeps notes in PostgreSQL, grown in four steps: it starts with its database on your machine, gains a Redis cache, moves to AWS with the database on Amazon RDS, and finally gets its backups.
  • task-run-on-demand (start) — A task carrying core/manual-trigger, deployed without starting on Kubernetes, Docker Compose, Terraform and CloudFormation, beside a task carrying nothing, with the command that starts a run on each target.
  • workload-identity-binding (authoring) — A single stateless app rendered on Kubernetes by the helm provider’s Workload synthesis — no external chart.

boundaries

components or modules placed in boundaries, and what crosses between them.

  • advanced-platform (advanced) — A multi-boundary Kubernetes platform that combines several mechanisms in one build from a single Developer-authored Aggregate: boundary-scope FeatureRecipes, parameter hoisting, the credential subsystem, and cross-boundary references resolving through Service DNS.
  • annotation-driven-monitoring (advanced) — This example attaches a monitoring Feature to six services across a nested topology without writing a single per-component features: block.
  • cloudformation-rds-stack (advanced) — A managed database and the application that reads it, authored once as developer intent and assembled into AWS CloudFormation stack templates.
  • cross-boundary-networking (advanced) — A two-component stack — an Adminer database UI and a PostgreSQL database — split across two boundaries, where Adminer must reach the database across the boundary seam.
  • import-dify (start) — A Dify chat application, exported in Dify’s DSL, imported by aggrega import into an Aggregate, a Release and a Manifest that build the standard library’s Dify installation, carrying it, for Kubernetes as written.
  • module-boundary-routing (advanced) — This example compiles two capabilities — a Thanos metrics read tier over object storage and a document database speaking the MongoDB wire protocol — from one Developer-authored Aggregate, and places each into a boundary of its own from the Release.

policy

governance policy that accepts or refuses a build, during the build or over its output.

  • policy-annotation-transform (advanced) — A governance policy gives every component of a shop the platform’s monitoring and an AWS IAM role.
  • policy-data-class-route (advanced) — An estate runs a claims assistant that handles restricted customer data, and a helpdesk assistant that handles none.
  • policy-in-ci (advanced) — Two ready-to-use rule scripts that read an Aggrega build’s output directory and refuse it when it breaks a rule.
  • policy-label-transform (advanced) — Governance plugins label every component this workspace deploys with its owner, the support tier its environment earns, its backup schedule and a short tag, so that no developer types any of them.
  • policy-org-overlay (advanced) — A team’s policy, its organization’s and its pipeline’s run together on one build, each attached in a configuration file of its own.
  • policy-payload-leaf-sensitivity (advanced) — This example teaches one house rule and the fact that makes it expressible.
  • policy-render-verdict (advanced) — One house rule, attached at the render-verdict role, judges the files a build writes for four targets and refuses a violation planted on each.

guardrails

a Release that is meant to halt, and the message it halts with.

  • adhoc-uses-socket (start) — This example teaches one line, and both halves of it.
  • ai-gateway-own-webhook-certificate (advanced) — This is an advanced example.
  • chart-from-git-repository (authoring) — A Helm chart does not have to come from a chart registry.
  • cloudformation-rds-stack (advanced) — A managed database and the application that reads it, authored once as developer intent and assembled into AWS CloudFormation stack templates.
  • credential-secretkeyref (start) — A single PostgreSQL database whose password is supplied by the credential subsystem, shown per provider.
  • datastore-backup (start) — A PostgreSQL database backed up on Kubernetes through Velero and through CloudNativePG, and on AWS through Amazon RDS’s own automated backups, on Terraform and on CloudFormation, and through AWS Backup, from one core/backup attachment the operator writes in each Release, with the refusal on a target that has no backup product.
  • extends-wrapper (authoring) — This example teaches one thing: a Component that extends another inherits that base’s whole data contract, so every Recipe written for the base already implements the extending Component.
  • memcached-cache (start) — This lean example compiles a single Memcached in-memory cache from one Developer-authored Aggregate to two realizations.
  • policy-annotation-transform (advanced) — A governance policy gives every component of a shop the platform’s monitoring and an AWS IAM role.
  • policy-data-class-route (advanced) — An estate runs a claims assistant that handles restricted customer data, and a helpdesk assistant that handles none.
  • policy-label-transform (advanced) — Governance plugins label every component this workspace deploys with its owner, the support tier its environment earns, its backup schedule and a short tag, so that no developer types any of them.
  • policy-org-overlay (advanced) — A team’s policy, its organization’s and its pipeline’s run together on one build, each attached in a configuration file of its own.
  • policy-payload-leaf-sensitivity (advanced) — This example teaches one house rule and the fact that makes it expressible.
  • policy-render-verdict (advanced) — One house rule, attached at the render-verdict role, judges the files a build writes for four targets and refuses a violation planted on each.
  • s3-object-store (start) — This example compiles one S3-compatible object store, the core/storage/s3-object-store component, to its two self-hosted realizations.
  • task-run-on-demand (start) — A task carrying core/manual-trigger, deployed without starting on Kubernetes, Docker Compose, Terraform and CloudFormation, beside a task carrying nothing, with the command that starts a run on each target.

catalog-authoring

a Component, Feature or Recipe written for the example, kept beside it or published to the catalog.

  • advanced-platform (advanced) — A multi-boundary Kubernetes platform that combines several mechanisms in one build from a single Developer-authored Aggregate: boundary-scope FeatureRecipes, parameter hoisting, the credential subsystem, and cross-boundary references resolving through Service DNS.
  • ai-gateway-own-webhook-certificate (advanced) — This is an advanced example.
  • chart-from-git-repository (authoring) — A Helm chart does not have to come from a chart registry.
  • cross-boundary-networking (advanced) — A two-component stack — an Adminer database UI and a PostgreSQL database — split across two boundaries, where Adminer must reach the database across the boundary seam.
  • extends-wrapper (authoring) — This example teaches one thing: a Component that extends another inherits that base’s whole data contract, so every Recipe written for the base already implements the extending Component.
  • mariadb-adminer (authoring) — This example compiles a small, real stack — a MariaDB database with an Adminer web UI in front of it — from a single Developer-authored Aggregate to two platforms.
  • mariadb-bitnami-credential-set (authoring) — A single MariaDB database realized by the Bitnami Helm chart, whose passwords are supplied by one multi-key referenceable secret (core/referenced-secret-set).
  • mcp-address-from-secret (authoring) — Some Model Context Protocol servers that someone else runs read their key from their own address — https://mcp.example.com/mcp?api_key=<key> — rather than from a request header.
  • multikey-secret-synth (authoring) — A single stateless app rendered on Kubernetes by the helm provider’s Workload synthesis — no external chart.
  • policy-data-class-route (advanced) — An estate runs a claims assistant that handles restricted customer data, and a helpdesk assistant that handles none.
  • postgres-three-realizations (authoring) — A PostgreSQL database and the application that reads it, deployed three different ways from one unchanged Aggregate: PostgreSQL running in the cluster, PostgreSQL as a managed cloud instance, and a PostgreSQL server that already existed before this Release was deployed.
  • workload-identity-binding (authoring) — A single stateless app rendered on Kubernetes by the helm provider’s Workload synthesis — no external chart.
  • workload-library-import (authoring) — A single stateless web service whose Recipe synthesizes its Kubernetes Workload from a shared library entry instead of an inline body.

cloud-infrastructure

Terraform or CloudFormation output for managed cloud services.

  • aws-rds-and-ecs-service (advanced) — One Aggregate holds a PostgreSQL database and the server that reads it.
  • cloudformation-rds-stack (advanced) — A managed database and the application that reads it, authored once as developer intent and assembled into AWS CloudFormation stack templates.
  • datastore-backup (start) — A PostgreSQL database backed up on Kubernetes through Velero and through CloudNativePG, and on AWS through Amazon RDS’s own automated backups, on Terraform and on CloudFormation, and through AWS Backup, from one core/backup attachment the operator writes in each Release, with the refusal on a target that has no backup product.
  • policy-payload-leaf-sensitivity (advanced) — This example teaches one house rule and the fact that makes it expressible.
  • policy-render-verdict (advanced) — One house rule, attached at the render-verdict role, judges the files a build writes for four targets and refuses a violation planted on each.
  • postgres-three-realizations (authoring) — A PostgreSQL database and the application that reads it, deployed three different ways from one unchanged Aggregate: PostgreSQL running in the cluster, PostgreSQL as a managed cloud instance, and a PostgreSQL server that already existed before this Release was deployed.
  • quickstart-web (start) — A small web application that keeps notes in PostgreSQL, grown in four steps: it starts with its database on your machine, gains a Redis cache, moves to AWS with the database on Amazon RDS, and finally gets its backups.
  • task-run-on-demand (start) — A task carrying core/manual-trigger, deployed without starting on Kubernetes, Docker Compose, Terraform and CloudFormation, beside a task carrying nothing, with the command that starts a run on each target.
  • terraform-declared-sensitivity (advanced) — A declaration that a value carries secret material is authored once, on a Component’s schema.
  • terraform-rds-module (authoring) — The same MariaDB intent as the terraform-rds example, rendered through the sourced shape of the Terraform provider: instead of an inline HCL body, the Recipe points at a local Terraform module and the compiler vendors it verbatim, then supplies its input variables from the developer and operator pillars.
  • terraform-rds (authoring) — A single MariaDB database authored once as developer intent and rendered to a Terraform HCL file that provisions a managed AWS RDS instance.

external-sources

a Recipe that fetches what it renders: an upstream chart, a git repository or a module.

  • advanced-platform (advanced) — A multi-boundary Kubernetes platform that combines several mechanisms in one build from a single Developer-authored Aggregate: boundary-scope FeatureRecipes, parameter hoisting, the credential subsystem, and cross-boundary references resolving through Service DNS.
  • ai-gateway-own-webhook-certificate (advanced) — This is an advanced example.
  • aws-rds-and-ecs-service (advanced) — One Aggregate holds a PostgreSQL database and the server that reads it.
  • cert-manager-tls (start) — This example compiles a small, real stack — a cert-manager certificate controller — from one Developer-authored Aggregate to Kubernetes.
  • chart-from-git-repository (authoring) — A Helm chart does not have to come from a chart registry.
  • contour-gateway (start) — This example compiles a small, real stack — a Contour ingress gateway — from one Developer-authored Aggregate to Kubernetes.
  • external-secrets-operator (start) — This example compiles a small, real stack — the external-secrets operator — from one Developer-authored Aggregate to Kubernetes, backed by the official external-secrets Helm chart.
  • harbor-stack (start) — This example compiles a real container registry to Kubernetes manifests from one Developer-authored Aggregate.
  • loki-logging (start) — This example compiles a small, real stack — a Grafana Loki log-aggregation server — from one Developer-authored Aggregate to Kubernetes, backed by the official Grafana Loki Helm chart in its single-binary shape.
  • mariadb-adminer (authoring) — This example compiles a small, real stack — a MariaDB database with an Adminer web UI in front of it — from a single Developer-authored Aggregate to two platforms.
  • mariadb-bitnami-credential-set (authoring) — A single MariaDB database realized by the Bitnami Helm chart, whose passwords are supplied by one multi-key referenceable secret (core/referenced-secret-set).
  • openbao-secrets (start) — This example compiles a small, real stack — a single OpenBao secrets server — from one Developer-authored Aggregate to Kubernetes, backed by the official OpenBao Helm chart.
  • quickstart-web (start) — A small web application that keeps notes in PostgreSQL, grown in four steps: it starts with its database on your machine, gains a Redis cache, moves to AWS with the database on Amazon RDS, and finally gets its backups.
  • sealed-secrets-controller (start) — This example compiles a small, real stack — the sealed-secrets controller — from one Developer-authored Aggregate to Kubernetes, backed by the official sealed-secrets Helm chart served from an HTTPS chart repository.

import

a project written in another format, drafted into Aggrega files by aggrega import, then reviewed and built.

  • import-agent-framework (start) — A declarative agent of Microsoft Agent Framework — one agent on an OpenAI model, searching documentation through an MCP server — drafted into Aggrega files by aggrega import, with the application’s image answered once in an answers file, and built for Docker Compose.
  • import-compose (start) — A Compose file running an API, the PostgreSQL database it keeps its notes in and a Redis cache, drafted into Aggrega files by aggrega import — the connections, the database’s settings, the password as a variable reference and each image’s tag carried over — and built for Docker Compose.
  • import-crewai (start) — The agent and task declarations of a CrewAI project in the classic layout — two agents on one OpenAI model, one task each — drafted into Aggrega files by aggrega import, with the image the crew’s program runs in answered once in an answers file, and built for Docker Compose.
  • import-dify (start) — A Dify chat application, exported in Dify’s DSL, imported by aggrega import into an Aggregate, a Release and a Manifest that build the standard library’s Dify installation, carrying it, for Kubernetes as written.
  • import-flowise (start) — A Flowise chatflow — a ChatOpenAI node, a Buffer Memory and a Conversation Chain — imported by aggrega import into an Aggregate, a Release and a Manifest that build for Docker Compose as written.
  • import-google-adk (start) — The Agent Config of an application built on Google’s Agent Development Kit — one agent on Gemini, with the Google Search tool ADK ships — drafted into Aggrega files by aggrega import, with the application’s image answered once in an answers file, and built for Docker Compose.
  • import-langflow (start) — Langflow’s Basic Prompting starter project, exported as JSON, imported by aggrega import into an Aggregate, a Release and a Manifest that build for Docker Compose as written.
  • import-langgraph (start) — The langgraph.json of a LangGraph application — one graph, keeping its state in PostgreSQL — drafted into Aggrega files by aggrega import, with the model the graph calls and the application’s image answered once in an answers file, and built for Docker Compose.
  • import-mcp (start) — A Claude Code .mcp.json listing three Model Context Protocol servers — two started from a command line and one someone else runs — drafted into Aggrega files by aggrega import, each server mapped to the realization of how it runs, and built for Kubernetes.
  • import-n8n (start) — An n8n workflow — a chat trigger, an AI Agent, an OpenAI Chat Model and a Simple Memory — imported by aggrega import into an Aggregate, a Release and a Manifest that build for Docker Compose as written.