What we ship, week after week.

Runtime security, stronger isolation, Trino public or private

You see what your containers really do, and isolation between organizations no longer rests on our code alone.

• A security agent runs on every node. It watches what containers actually do, and every alert names the organization it concerns.
• All the alerts are in one place. A page in the control center gathers the security alerts of the whole fleet.
• Isolation moves into Kubernetes. A request that tried to bypass the platform is refused by the Kubernetes API itself, no longer by our code alone.
• You choose whether Trino is exposed. A Data Dock's Trino is public or private, and you switch it in one click from the console.
• The network is closed by default. Access to Trino, to pipelines and to managed PostgreSQL databases is protected without you writing a rule.
• You choose your vulnerability databases. The ones image scanning uses, including on an installation with no internet access.
• Third-party images are configurable. You point them at your own registry from the installation chart.

Runner egress ports, bucket objects in bulk

Your builds finally reach repositories that do not listen on 443, and you tidy a bucket without opening it file by file.

• You open a precise port. A runner can reach an apt repository on port 80 or an internal registry on port 5000. Before, only 443 went through.
• Or you allow everything. A runner pool can run with no restriction at all, for builds that download from more domains than a list can hold.
• A bucket behaves like a table. Column sorting, search, multi select, bulk delete and pagination.

Service links in Terraform, the control center rebuilt

You describe in Terraform which services may reach each other, in the same place as the rest of your infrastructure.

• You declare call permissions in Terraform. The hyperfluid_service_link resource states which services may call each other, in the same files as the rest of your infrastructure.
• An application exposes several ports. As many as it needs, and Terraform can refer to it by its slug.
• The control center looks like the console. A collapsible navigation rail, breadcrumbs, and a palette that opens any page in two keystrokes.

The audit log becomes readable in the console

You know who asked for what, on which resource, and what was decided, without writing a single query.

• Every access decision is readable. The Vauban page shows who asked, on which resource, what was decided, and the rule that decided it.
• SQL queries come with detail. You see the schemas, tables and columns each one touched, with the row filters and masks applied.
• You filter the list, then you open a row. By action, by resource, by decision or by event type, and each row shows the full request.

Self-service Slurm, third-party AI models, GitLab

You stand up a compute cluster with no ticket, you call third-party models with your usual key, and you code on a GitLab repository.

• You create a Slurm cluster yourself. With its partitions, its node sizes and an ssh login node. No ticket to open.
• Job accounting is optional. You get the history with sacct and you set QOS limits per partition.
• Third-party models join the catalogue. Each with its context window and its price, called through the same endpoint and the same key as your local models.
• Credits to pay for them. A balance, a statement of what was granted and spent, and a warning before a call is refused.
• You work on a GitLab repository. From a workstation, then you open the merge request and follow it from the console.
• One API key can no longer starve the others. You set its rate ceiling yourself, within the limit the platform allows.
• hfctl handles compute docks. You create one, list it, resize it and connect to it from the terminal.

Twelve SQL connectors, agent skills, admission control

You query databases the platform does not host, and your agents change skills without restarting.

• Twelve more databases in the SQL catalogue. MySQL, MariaDB, ClickHouse and the JDBC family: a catalog can point at a database we do not host.
• Agent skills are edited in the console. A change reaches workstations that are already running, with no restart.
• The console does what the terminal did. It shows which skills answered, a table picker grouped by schema, and thinking time under each answer.
• hfctl talks to agents. You manage them, edit their skills and chat with them from the terminal.
• hfctl drives pipelines. You create one, trigger it and follow its run to the end.
• The AI gateway can say no. An admission policy decides which calls it accepts, and refuses the rest explicitly.

Service links on the command line, traced maintenance

You declare from the terminal which service may reach which, and you know what each maintenance run did to your tables.

• hfctl declares links between services. You state which service may call which, without going through the console.
• Every Iceberg maintenance run leaves a trace. It has its own identity, its result metrics and its logs, so you know what ran and what it did.
• Model keys live in the vault. The pipeline names the key instead of carrying it in the clear.

Catalogs onto your existing databases, workstation ports

You query your databases where they are, without moving them, and your workstation publishes its ports on its own.

• A catalog can point elsewhere. At a database the platform does not host, with a credentials form specific to each connector.
• A workstation's ports open in one click. Any port your code serves shows up on its own in the console.
• An agent skill stays inside its perimeter. It names the tables it may read, and its search goes no further.
• A map shows who talks to whom. The declared links between services are readable service by service.

Scheduled queries, built-in support, governed GPU

You schedule a query and let it run, you open a ticket without leaving the console, and the GPU is driven like a resource.

• A query can run without you. You write it, you schedule it, it runs in the background with its own authorization.
• Support is in the console. You open a ticket from the interface, it lands straight with the platform team.
• The GPU becomes a governed resource. Entitlement, budget and pool, granted organization by organization.
• An undersized application flags itself. Seven-day p95 CPU shows the one that reserves more than it uses.

TLS on the PostgreSQL wire protocol, object level permissions

Your data API connections are encrypted all the way to the client, your authorizations reach down to the object, and you size an application with a single number.

• Data API connections are encrypted all the way to the client.
• Bucket authorizations reach down to the object.
• One vCPU number per tier, from which the reservation and the ceiling are derived.

Private secrets, workstation networking, platform changelogs

You keep your secrets in an area that is yours alone, you control your workstations' networking, and you clone several repositories into one.

• A reserved secret path per user, visible to its owner alone.
• A network tab on workstations, with custom allow lists.
• Several repositories cloned into one workstation.
• Platform news shows up directly inside the console.

One Kubernetes namespace per environment

• Every environment gets its own Kubernetes namespace, enabled organization by organization.
• An environment's resources are isolated from the others, down to the network.

Capacity alerting, agent conversations, FHIR demo

You let an agent answer several conversations at once, and you are warned before capacity runs out.

• Capacity alerts, with a notification plane in the console.
• Agents answer mail concurrently, serialized per conversation.
• A complete FHIR demo in a single command.

Public trial signup, managed agent mailboxes

You start a trial without asking us, and your agents get mailboxes of their own.

• Public trial signup, with an approval queue in the backoffice.
• Platform hosted mailboxes for your agents.

Token consumption per model and per principal

• Token consumption charts per model, over the period you pick.
• The same view per principal: users and service accounts, side by side.
• Enough to know exactly who consumes what, model by model.

Platform administration backoffice

You administer the platform from a backoffice separate from your organizations' console.

• A dedicated backoffice for platform administration, separate from the organization console.
• Organization creation, account management, cross tenant oversight.
• Built on the same design system as the console.

Bulk grants, group roles and permissions

• Bulk editing of grants given directly to a user.
• Role and permission management at group level, not just per person.
• Iceberg schema deletion from the interface.

Token metering per principal, users and service accounts alike

• Token consumption is attributed to each principal: user or service account.
• An automation's OCR model is configured at creation time: key, name and URL.

A denial names the permission that was missing

• An access denial names the permission that was missing, in the console and in hfctl.
• No more guessing which right to ask your administrator for.

Import and export of container app environment variables

• Export of a container app's environment variables.
• On import, hfctl's secret: syntax is recognised: a variable can point at the vault.
• hfctl reports that an update is available after a command.

Realtime AI consumption, dense series and quick ranges

• Denser consumption series, quick ranges and refresh control.
• Realtime tracking becomes readable over short windows.

Cluster GPU inventory, consumption dashboard

You see the GPU fleet available, its real usage, and the history of what you consumed.

• A Resources tab on the AI gateway: GPU inventory and usage.
• Realtime and history modes on the consumption dashboard.

AI gateway: token metering and external models

You measure your inference consumption precisely, and you expose models served outside the platform.

• All inference goes through the gateway, for a reliable measure of usage.
• Models served outside the platform, exposed and discovered automatically.
• The console moves to Tailwind CSS v4.

Breadcrumbs on every detail page, faster local OCR

• A breadcrumb on every detail page: home, section, resource, tab.
• Local OCR sped up by reading the PDF text layer directly, when there is one.

Managed Airflow, OCI containers in workstations

You provision Airflow from the console, and you run containers directly inside your workstation.

• Managed Airflow, provisioned and supervised from the console.
• OCI containers usable directly inside a workstation.
• A PDF capable OCR playground.

A console rebuilt as a service catalogue

You find your services in a catalogue, with your favourites pinned. The features do not change, the way you reach them changes entirely.

• Service catalogue navigation, with pinnable favourites.
• The SQL Engine adopts the same interface grammar as containers and databases.
• Agents ask a clarifying question when the request is ambiguous.
• Precomputed embedding contract: the pipeline embeds, Bifrost copies.

Agents reachable by email, governed queries from the CLI

You write to an agent like a colleague, it replies in the thread. And you query your data from the terminal, under your policies.

• An agent reads a mailbox and replies in the conversation thread, over IMAP and SMTP.
• A setup wizard walks through connecting the mailbox, provider by provider.
• hfctl query and hfctl search: query the data plane from the terminal, under policy control.

Per organization identity providers, dedicated OCR playground

• Each organization can plug in its own identity provider, with invitation based sign in.
• A dedicated OCR playground for vision language models.
• Log explorer: volume histogram, live follow and export.

Per organization log retention, advanced filters

• Log retention is set organization by organization.
• Advanced filters in the log explorer.

Embedded logs, and the agent runtime wired end to end

• A log engine embedded in the platform, with its own search page in the console.
• The agent runtime is wired end to end: from the creation wizard through to chat.
• Backup management on an existing database, from the console and from hfctl.

User defined AI agents, end to end

You define your own AI agents, from declaration through to conversation.

• User defined AI agents, from declaration through to conversation.
• Creation of a managed PostgreSQL database from a backup.
• Dashboards: variables, cross filtering, auto refresh and text widgets.
• Kafka access by service account, over OAuth.

AI first dashboards, Kafka topic management

You build your dashboards with AI, and you manage your Kafka topics from the interface.

• AI first dashboards, built inside the console.
• Kafka topic management from the interface.
• The SQL Engine gets its own section: column browsing, cluster statistics and an access tab.

Shared model playground, multi profile wallet for hfctl

• Playground and code samples for shared models, with the gateway URL.
• hfctl handles several authentication profiles in one wallet.
• A default backup target on every environment.

Guardrails and groups in Vauban, dark theme in the console

You set guardrails per resource and per group, and nothing is exposed to the internet unless you decided it.

• Vauban: per resource access levels, guardrails and group management.
• Light and dark theme, your pick, from the user menu.
• Databases and applications are private by default, exposure becomes an explicit choice.
• hfctl gains a command group for key value caches.

PostgreSQL quotas, per organization storage zones

• Capacity quotas on managed PostgreSQL databases.
• Ceph storage zones enabled per organization.
• The console spots environment variables that look like secrets and offers to move them into the vault.

Inbound email interface in the console

• The inbound email interface lands in the console.
• Workstation ergonomics reworked.

Inbound email, capacity quotas, browsable secrets

• An inbound email transport, on the platform side.
• Bulk import of environment variables, and a browsable picker over the secret tree.
• Capacity quotas on container apps.

Terraform provider served by the console, twenty more connectors

• The console serves the Hyperfluid Terraform provider as a registry.
• Twenty more open data connectors, including data.gov.uk and SCB Sweden.
• Configurable Keycloak login theme per organization.

Filterable open data catalogue

• Filterable open data catalogue, with each connector's metadata.
• Managed image source in the new application wizard.

Twenty open data connectors, French and European

You cross your data with twenty French and European public sources, without writing an ingestion script.

• Twenty open data connectors: DREES, Ameli, Crossref, Zenodo, TfL, ONS and more.
• French connectors: data.gouv.fr, Enedis, DVF, GRDF, SNCF, RATP.
• hfctl configures itself from the service account file.
• Slimmer workstation images, and a Rust base.

Trino control plane, Dagster orchestration, Forgejo CI

• A Trino control plane: monitoring, scaling and catalog management.
• Dagster orchestration, from CRD through to the interface.
• Forgejo CI jobs push to the internal registry.
• One click Trino enablement, in a dedicated SQL Engine section.

Distributed Bifrost, embedded monitoring, a wider hfctl

You scale up: Bifrost becomes distributed and autoscaled, and you monitor the platform from the console.

• Bifrost becomes a service of its own, with autoscaling.
• An embedded monitoring system, in production.
• Managed PostgreSQL exposed through Trino catalogs.

Workstation environment templates, Source Control

• Environment templates for workstations: CRD, catalogue and authoring interface.
• Source Control joins the catalogue, backed by Forgejo.
• hfctl gains the storage and buckets commands.

AI assisted editing in workstations, first open data connectors

• AI assisted editing in workstations, Cmd-K style.
• A shared Qwen3 model, with no organization or key coupling.
• First open data connector: the World Bank, into an Iceberg table.
• Vauban moves from RBAC to ABAC for console access.

hfctl available for macOS

• hfctl is distributed for macOS as well as Linux.
• OS detection in the install script.

Workstations: editable IDE, zero config LSP, source control

• The workstation IDE becomes editable, with multi file tabs.
• Completion, hover and code navigation, with no configuration.
• A source control tab, with a live branch indicator.

hfctl, the Hyperfluid command line

You drive the platform from the keyboard, from model serving through to a database's logs.

• hfctl, the Hyperfluid command line, in full.
• Sapience commands: model serving, inference, shared models and API keys.
• Member invitations from the console.
• Streaming database logs, in the console and from the CLI.

Configurable runtime for container apps

• The runtime class for container apps is configured on the platform side.

Container app persistence, connector scheduling

• Built in persistent volume for a container app.
• Configurable cron schedule on connector pipelines.
• Image pull testing and a complete edit surface on an application.

Shared per organization Ceph object storage

• Shared per organization Ceph object storage, partitioned by environment.

Custom domains end to end, files mounted into containers

You serve your applications under your own domain names, from verification through to go live.

• Your own domain names on applications, from verification through to go live.
• Files mounted into a container: inline config, or a secret served as a file.
• Responsive Data APIs page, and a reworked sidebar.

Custom domains: operator reconciliation

• The operator reconciles custom domains.

Non PDF routing in the file sorter

• Files that are not PDFs are routed explicitly by the file sorter.

Custom domains: the foundations

• The foundations of custom domains: API, database and ownership verification.

Default medallion schema on Iceberg

• A default medallion schema on Iceberg catalogs.
• Cascading deletion of a lakehouse's resources.

Connectors: statistics and bucket navigation

• A statistics tab on every connector.
• Google Drive connector detail page, with bucket navigation.
• Ceph credentials are published into the secret store.

On demand PostgreSQL backups, Google Drive connector

• On demand PostgreSQL backups, alongside scheduled ones.
• Google Drive connector, end to end.
• A database user's secrets are reachable from its tab.

Backup targets, default environment per organization

• Backup targets declared as resources.
• A default environment for every organization.
• Badges on Trino tables.

Managed PostgreSQL reachable from outside

• A managed PostgreSQL database can be reached from outside the cluster.
• The endpoint is published into the user's secrets.

Managed PostgreSQL users, path based secret organization

• Managed PostgreSQL users, declared and reconciled as resources.
• Secrets are organised by path.
• RNIC open data connector.

OCR: automatic resume and processing context tracking

• OCR resumes where it left off, without redoing work already done.
• Configurable backoff on model calls.

Managed PostgreSQL: the CRD and its operator

• Managed PostgreSQL: the CRD and its operator.
• Configurable Ceph zones on a Data Dock.
• A reusable log viewer in the console.

Hybrid search: separate queries, merged results

• Hybrid search runs its two queries separately before merging the results.

Continuous Bifrost indexing

• Bifrost indexing runs continuously.

Tunable result fusion for hybrid search

• A fusion parameter on hybrid search, for a predictable merge of results.

Redesigned data product explorer

• The data product explorer is redesigned from the ground up.

Password reset from the cockpit

• Password reset from the cockpit.

Cockpit v3: admin panel and automatic onboarding

You administer the platform from a real panel, and a new organization starts with no manual step.

• Cockpit v3: a stateful admin panel, for the platform.
• Automatic onboarding of a new organization.

BGE embeddings, and the Hippocampe memory layer

You get a three level memory layer, and vector search moves to BGE embeddings.

• BGE embeddings for vector search.
• Hippocampe: a three level memory layer.

Extra fields on the import API

• Extra fields carried through the import API.

Ceph lifecycle and status

• Ceph storage lifecycle and status, visible in the console.
• The import API's extra fields are reused by pipelines.

Omnifeed, and page level document splitting

• Omnifeed: a single entry point to feed pipelines.
• Document splitting by page number, as reported by OCR.

Sign in screens in your organization colours

• Sign in screens take your organization's colours.
• Cilium network policies on container apps.

Self service and quotas

• Self service onboarding, with per organization quotas.

Kata containers: hardware isolation for applications

• Applications can run in Kata containers, isolated at hardware level.

Registry secrets and network policies for containers

• Registry secrets and network policies on container apps.

Lakehouse v2 blueprint on Ceph

• A Lakehouse v2 blueprint, backed by Ceph storage.

Iceberg table optimization

• Iceberg table optimization, triggered from the platform.
• Faster change detection on application pods.

CaaSThor: container apps, ingress and logs

You deploy a container app from the console, with its ingress, its pods and its logs on the same page.

• CaaSThor: deploy a container app from the console.
• Ingress, pod list and logs, on the same page.
• Bucket picker on Iceberg catalogs.

Kafka, and a rebuilt Bifrost index and cache layer

• Kafka joins the service catalogue.
• Bifrost indexes and caches rebuilt.

Secret store

• A secret store built into the platform.

Bifrost index pre computing

• Bifrost indexes are pre computed rather than built on demand.

Observatory metrics service

• Observatory: a metrics service for the platform.

Internal labeler in production

• The internal labeler goes to production, replacing the external API.

Global models, log expiry, Petite Requete monitoring

• Global models, available across the platform.
• Petite Requete monitoring.
• Automatic expiry of pipeline logs.

Local GPU OCR with Qwen2.5-VL

Your documents no longer leave the platform to be read: OCR runs locally on GPU.

• OCR runs locally on GPU, with Qwen2.5-VL, with no external API call.

Batch creation of chunk references

• Batch creation of chunk references.

Petite Requete, and the Ceph Data Dock

You query your data from Petite Requete, and your object storage moves onto Ceph.

• Petite Requete: the SQL runner takes its name and its documentation.
• A Data Dock backed by Ceph.
• Reworked object storage interface.

A SQL runner in the console

• A SQL runner in the console, to query without leaving the platform.

S3 copy in pipelines

• S3 copy in pipelines.

Table duplication within an Iceberg catalog

• Table duplication within one Iceberg catalog.

The hyperfluid-users role

• A hyperfluid-users role, the base of platform access.

Pipelines and navigation redesigned

• Pipelines and console navigation are redesigned.
• Lazy loading of heavy pages.
• Dynamic values in labelling.

Import API connection and suffix control

• An import API connection type in pipelines.
• File suffix control on import.

File sorting in pipelines

• A file sorting step in pipelines.

ZIP imports and exports, Vauban 0.2

• ZIP format imports and exports.
• Vauban 0.2, and the first public landing page.

PostgreSQL Data Dock, and row level security

You plug a PostgreSQL database in as a source, and your policies filter down to the row.

• A PostgreSQL Data Dock.
• Row level security in policies.
• User and role synchronization from an external API.