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 KubernetesWhat you get out of the box, and how it is packaged: one chart on top of standard infrastructure.
→
2 · Extending FredAgents, Knowledge Bases, applications: what each one is for, and how to choose.
→
3 · In actionKubernetes 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
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 passwordhelm 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
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.
Three kinds of extension, each with a clear scope: agent pods, Knowledge Bases, applications.
Each one registers with Fred; a platform admin then enables it per team, like any built-in feature.
Upgrading Fred never conflicts with your code, because none of your code is in Fred.
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 need
Build
Built with
Deployed with
Users see
A new behaviour in the chat
Agent pod
fred-sdk, fred-runtime
agent-pod chart
new agents in the catalog
Agents that know an external source
Knowledge Base
fred-sdk
knowledge-base chart
a library kept up to date
Its own screens, data and workflow
Application
anything: your UI, your API
your own chart
a 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 collectionmake k3d-up# the operator's own credential: the model key, as before any Fred installkubectl -n fred create secret generic fred-model-credentials \
--from-literal=OPENAI_API_KEY=<your key>
Generated infrastructure passwords live in one Secret the instance creates; the apps read them by reference.
What the operator supplies, the operator creates. Fred's pods do not start without it.
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 pinsmake k3d-app APP=fred
# or any other published releasemake k3d-app APP=fred RELEASE=3.6.1
Helm installs oci://ghcr.io/thalesgroup/fred-helm/fred; every image comes from ghcr.io. No clone, no build.
Values checked and rendered before anything changes in the cluster; the command waits until every pod is ready.
First login: register on Keycloak, paste the bootstrap token, and you are the platform administrator.
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 valuesmake k3d-app APP=fred DIR=../fredmake k3d-app APP=fred-evaluator DIR=../fred-agent-evaluator# an extension that keeps its own deployment definitionmake k3d-app DIR=../my-agents
Only what changed is rebuilt and rolled out; rerun after any change.
Without DIR, the same command goes back to the published release.
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
Infrastructurestandard services on any Kubernetes cluster
Fredone chart, published images, ready to use
Extensionsagent pods, Knowledge Bases, applications: each in its own repository
Fred
github.com/ThalesGroup/fred
Charts
artifacthub.io/packages/helm/fred/fred
Evaluator
github.com/fred-agent/fred-agent-evaluator
Samples
github.com/fred-agent/fred-samples
Local instance
github.com/fred-agent/fred-deployment-factory
Docs
site.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 · ReleaseFred or an application publishes a new chart and images.
→
2 · Renovate PRThe factory's pinned version is raised; its CI checks the instance's values against the new chart.
→
3 · MergeThe factory now deploys the new release by default.
→
4 · Upgrade k3dgit 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 cluster
make k3d-up, the model key Secret, make k3d-app APP=fred, make k3d-app APP=fred-evaluator
Rehearse the upgrade to a new release
Once its Renovate PR is merged: git pull in fred-deployment-factory, then make k3d-app APP=fred
Run another published release
make k3d-app APP=fred RELEASE=x.y.z
Test my Fred code
make k3d-app APP=fred DIR=../fred, rerun after any change
Go back to the published release
make k3d-app APP=fred, without DIR
Deploy my own application
make k3d-app DIR=../<application>
Stop the cluster, keep the data
make k3d-down, then make k3d-up to resume
Start over
make 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.