Fred · deployment model

Deploying Fred,
the Kubernetes way

A complete agentic application, packaged like any cloud-native product: one Helm chart, published images, your values and your Secrets. Extended without forking it, and installed the same way on a laptop as in production.

Fred · October 2026 · verified against Fred 3.6.1 and fred-agent-evaluator 1.2.0

Three parts

From the platform, to your extensions, to a running cluster

1 · Fred on Kubernetes What you get out of the box, and how it is packaged: one chart on top of standard infrastructure.
→
2 · Extending Fred Agents, Knowledge Bases, applications: what each one is for, and how to choose.
→
3 · In action Kubernetes and its infrastructure, then Fred, then the evaluation application, on a local k3d cluster.

Everything shown is open source and published: charts, images and the local deployment.

Part 1 / 3

Fred on Kubernetes

A ready-to-use agentic application, installed like any other Kubernetes product.

Out of the box

A complete agentic application, not a framework

Web UIConversations with agents, team spaces, document libraries, administration.
Agent runtimeRuns agents and their tools; agent templates and capabilities are enabled per team.
Document ingestion and searchLibraries ingested, indexed and searched by agents, with access control on every document.
Control planeTeams, members, access rules, model choices, the catalog of agents and applications.

Install it, sign in, enable what each team needs: no code to write before the first useful conversation.

The layers

Standard infrastructure below, Fred in one chart, extensions on top

Extensionseach its own repository and chart
agent podsKnowledge Basesapplications
Fredone Helm chart, four images
frontendfred-agentsknowledge-flow + workerscontrol-plane + worker
Infrastructureoff-the-shelf services you operate
PostgreSQLOpenSearchKeycloakOpenFGATemporalS3 or GCS storage
Kubernetesany conformant cluster
GKE, AKS, on-premises...k3d on a laptop

Fred brings no infrastructure of its own: it uses the standard services your platform already runs.

Packaging

Installed like any cloud-native product

# the operator's values: addresses, choices
# and Secret references, never a password
helm install fred \
  oci://ghcr.io/thalesgroup/fred-helm/fred \
  --version 3.6.1 \
  -n fred -f my-values.yaml

Documented on Artifact Hub: the chart's README, values and their schema.

  • One chart, published as an OCI artifact; four images on ghcr.io, tagged with the release.
  • Credentials by reference: the operator creates Secrets before the install; the values only name them.
  • Each release ships an operator guide: what to change, in what order, how to roll back.
  • Values validated by a schema: a wrong key is refused at install, not discovered in production.

The same chart and the same images, from a laptop to a production cluster.

Self-documented

One public page tells an operator everything

artifacthub.io/packages/helm/fred/fred

fred 3.6.1 · Apache-2.0

Installhelm install fred oci://ghcr.io/thalesgroup/fred-helm/fred
READMEwhat it deploys, requirements, credentials, first login
Default values and their schemaevery setting documented; a wrong key is refused at install
Versions, operator guides, security reportevery release, and a scan of every image it runs
  • No meeting, no account, no contract: a Kubernetes operator reads one page and installs Fred with one command.
  • Nothing to keep in sync: the page is generated from what each release publishes: the chart's README, its values and schema, its images.
  • The same on every platform: GKE, AKS, on-premises or a laptop. k3d, in part 3, is this same install made comfortable.

That is cloud-native: standard tools, one public page, one command.

Part 2 / 3

Extending Fred

Your agents, your sources, your products: next to Fred, never inside it.

The picture

Fred at the centre, extensions around it, Kubernetes underneath

KUBERNETES CLUSTER INFRASTRUCTURE PostgreSQL OpenSearch Keycloak OpenFGA Temporal S3 storage APPLICATIONS Evaluation /apps/evaluation/ Your product /apps/<id>/ Fred one Helm chart, four images Web UI Agent runtime Knowledge Flow Control plane AGENT PODS Your agents agent-pod chart Sample agents agent-pod chart listed in Fred's agent catalog KNOWLEDGE BASES Git repository knowledge-base chart Shared folder knowledge-base chart keep team libraries in sync Users one sign-in Sources folders, Git, document servers

Each extension: its own repository, its own chart, its own release, enabled per team inside Fred.

The rule

Never fork Fred: deploy next to it

An extension lives in its own repository, builds its own image, ships its own release, and is deployed with a chart. Fred is a dependency you consume, never source code you patch.

Extension 1 / 3

Agent pod: your agents, in your image

What it is

  • Agents written with Fred's libraries (fred-sdk, fred-runtime), packaged in your own image.
  • Deployed with Fred's generic agent-pod chart: your image, your configuration.
  • Fred lists its agents once the control plane knows the pod; users find them in their agent catalog and chat with them.

Choose it when

  • You need a new behaviour in the conversation: a specialist, a workflow, human approval steps.
  • Your agents call your own tools or systems.
  • Example: fred-samples/agents, from a general assistant to multi-agent teams.

The extension for what happens inside a conversation.

Extension 2 / 3

Knowledge Base: keep a team's documents in sync with a source

What it is

  • A small pod, written with fred-sdk, that tells Fred where a team's documents come from and keeps them up to date.
  • Deployed with Fred's generic knowledge-base chart: a worker that runs the synchronizations, and a Job that declares it to Fred.
  • Fred does the rest: ingestion, indexing, search and access control.

Choose it when

  • The documents live somewhere else and keep changing: a shared folder, a Git repository, a document server.
  • You want agents to answer from them without users uploading anything.
  • Examples: fred-samples/knowledge-bases, a local folder and a Git repository.

The extension for what agents know.

Extension 3 / 3

Application: a complete product inside Fred

What it is

  • Your own UI, and your own API if you need one: images you build, released on your own cycle.
  • Deployed with your own chart; Fred's gateway serves it at /apps/<id>/, inside the Fred interface.
  • Your API authorizes its own data; it may run its own agents.

Choose it when

  • The work needs its own screens, data and workflow, beyond a conversation.
  • It has its own users' journey: create, review, compare, report.
  • Example: fred-agent-evaluator, evaluating agents against versioned test sets.

The extension for a whole product, sharing Fred's sign-in, teams and permissions.

Choosing

Which extension for which need

You needBuildBuilt withDeployed withUsers see
A new behaviour in the chatAgent podfred-sdk, fred-runtimeagent-pod chartnew agents in the catalog
Agents that know an external sourceKnowledge Basefred-sdkknowledge-base charta library kept up to date
Its own screens, data and workflowApplicationanything: your UI, your APIyour own charta product under /apps/<id>/

All three register with Fred, are enabled per team by an admin, and follow Fred's sign-in and permissions.

Start with the smallest one that does the job: an agent before an application.

Part 3 / 3

In action, on k3d

A local Kubernetes cluster, deployed exactly as production: published charts, published images, the operator's values and Secrets.

fred-deployment-factory

The local instance owns its values, the products own their charts

Published by each product

  • Fred: chart fred and four images.
  • fred-agent-evaluator: chart fred-evaluator and three images.
  • Each release: a version, release notes, an operator guide.

Held by the instance

  • The infrastructure chart: Kubernetes services, observability.
  • For each application: the published version it runs, and its values.
  • The operator's Secrets, created once per cluster.

The same split as any GitOps repository: no clone and no build to install a release.

Step 1 / 3

Kubernetes and its infrastructure

# a k3d cluster, then PostgreSQL, OpenSearch, Keycloak, OpenFGA, Temporal,
# S3 storage, and the observability: Prometheus, Grafana, log collection
make k3d-up

# the operator's own credential: the model key, as before any Fred install
kubectl -n fred create secret generic fred-model-credentials \
  --from-literal=OPENAI_API_KEY=<your key>

A production-shaped platform, before a single Fred pod runs.

Step 2 / 3

Fred, from its published release

# the published chart and images, at the version the instance pins
make k3d-app APP=fred
# or any other published release
make k3d-app APP=fred RELEASE=3.6.1

Open http://localhost:8088: a ready-to-use Fred.

Step 3 / 3

An application next to it: the evaluator

make k3d-app APP=fred-evaluator
  • Its own chart and images, from its own repository and release cycle.
  • Its service identity is created in Keycloak from what it declares.
  • Fred already knows it: the instance's values register it.
  • A platform admin enables Evaluation for a team.
  • It appears inside Fred at /apps/evaluation/, with the same sign-in.
  • Agents, Knowledge Bases and applications follow the same path.

One command per product; each one deployed from what it publishes.

For developers

The same instance, with your checkout

# build the images from your checkout, deploy its chart, same values
make k3d-app APP=fred DIR=../fred
make k3d-app APP=fred-evaluator DIR=../fred-agent-evaluator

# an extension that keeps its own deployment definition
make k3d-app DIR=../my-agents

What works here has met the real chart, the real identities and the real permissions.

Take away

Standard packaging, clear extension points, one way to deploy

Infrastructure standard services on any Kubernetes cluster
Fred one chart, published images, ready to use
Extensions agent pods, Knowledge Bases, applications: each in its own repository
Fredgithub.com/ThalesGroup/fredChartsartifacthub.io/packages/helm/fred/fred
Evaluatorgithub.com/fred-agent/fred-agent-evaluatorSamplesgithub.com/fred-agent/fred-samples
Local instancegithub.com/fred-agent/fred-deployment-factoryDocssite.fredlab.dev
Upgrades, rehearsed before production

Every new release is upgraded on k3d first

Renovate is a bot that watches the published charts. When Fred or an application publishes a release, it opens a pull request in fred-deployment-factory that raises the pinned version, for example 3.6.1 → 3.7.0.

1 · Release Fred or an application publishes a new chart and images.
→
2 · Renovate PR The factory's pinned version is raised; its CI checks the instance's values against the new chart.
→
3 · Merge The factory now deploys the new release by default.
→
4 · Upgrade k3d git pull the factory, then make k3d-app APP=fred: an in-place upgrade, data kept.

Step 4 is the upgrade an operator runs in production: the same chart, the same database migrations, the same new settings, on a cluster that already holds accounts and documents.

The progress: an upgrade of Fred or of any application is tested on k3d, with data, before it reaches production.

Cheat sheet · from fred-deployment-factory

I want to...

make k3d-app converges: the first run installs, the next ones upgrade in place and keep the data.

I want to...Run
Install everything on a new clustermake k3d-up, the model key Secret, make k3d-app APP=fred, make k3d-app APP=fred-evaluator
Rehearse the upgrade to a new releaseOnce its Renovate PR is merged: git pull in fred-deployment-factory, then make k3d-app APP=fred
Run another published releasemake k3d-app APP=fred RELEASE=x.y.z
Test my Fred codemake k3d-app APP=fred DIR=../fred, rerun after any change
Go back to the published releasemake k3d-app APP=fred, without DIR
Deploy my own applicationmake k3d-app DIR=../<application>
Stop the cluster, keep the datamake k3d-down, then make k3d-up to resume
Start overmake k3d-wipe, then make k3d-up: deletes accounts, documents and runs

No in-place downgrade: database migrations do not go back. To run an older release, start over.