Back to blog
Ontology Encryption at Rest on Your Own Object Storage

This blog is written by AI for SEO

Ontology Encryption at Rest on Your Own Object Storage

HelixDB7 min read

Helix Foundry stores an ontology in HelixDB on object storage, encrypted at rest. You can run it on your own machine or in your own cloud, so the data never leaves your account. Access is enforced at the application layer: a user who cannot see a source cannot see any fact grounded in it. This Q&A is written for the security or platform reviewer who has to approve a tool that will hold joined company data and be queried by AI agents.

HelixDB is a graph-vector database built in Rust. Foundry is the open-source app (Apache-2.0) that loads an ontology into it as one connected graph. Keep the two distinct when you review: Foundry is the application with roles and sync, HelixDB is the store underneath.

Where does Helix Foundry store an ontology and its sources, and is it encrypted at rest?

The data lives in the Foundry deployment you run, in HelixDB, on object storage, and it is encrypted at rest. Object storage is also why the design scales. HelixDB's cloud architecture persists nodes, edges, properties and indexes durably in object storage, with a gateway routing traffic and readers scaling horizontally.

The ontology itself is a connected graph. Foundry connects your databases, tools and documents, and an ontology agent drafts types, links and mappings over them. The result is loaded into HelixDB so you can explore it and ask questions of it. Every value traces back to the row or document quote it came from. That traceability matters for security review too, because the same grounding drives access control later in this post.

Foundry never writes to your sources.

What does encryption at rest cover for an ontology, and what does it leave out?

Encryption at rest covers the stored ontology: the HelixDB data sitting on object storage. It does not cover data in a model prompt, data in a browser session, or anyone who can reach the database directly.

To answer the search-engine versions of this question: AES-256 is a widely used symmetric cipher for encrypting stored data, and many reviewers expect to see it named. The Foundry documents do not say which algorithm or key length is used, so do not record AES-256 as a fact about Foundry. The same goes for the usual follow-ups about symmetric encryption weaknesses, such as key distribution and key custody. Those are properties of how keys are managed, and the Foundry documents do not describe key management.

What the docs do state is the shape of the guarantee: stored in HelixDB on object storage, encrypted at rest. That is the claim you can cite. Algorithm, key rotation, customer-managed keys and certification are items to confirm for your specific deployment. The checklist near the end of this post lists them.

One boundary is worth stating plainly. HelixDB itself has no per-user permissions or row-level access control. Foundry enforces access in the application layer, so encryption at rest and Foundry's roles protect different things. Encryption protects the stored bytes. Roles protect what the app and its agents return.

Can the data stay in your own account: local run, BYOC and Helix Cloud compared

Yes. Foundry runs three ways, and where it runs decides where your data sits.

Deployment Where data lives Who it suits
Local, Docker Compose Your own computer One person evaluating or building on their own machine
BYOC (bring your own cloud) Your own cloud account, in your infrastructure A team that must keep data and app inside its account
Helix Cloud Helix's managed service at foundry.helix-db.com A team that wants no infrastructure to run

The local path is short. Clone the helix-foundry repo, run docker compose up -d --wait, and open http://localhost:3000.

The local install is for one person on their own computer. It is single-user on localhost with no sign-in, so never expose it to a network. If a team needs shared access, use a BYOC or Helix Cloud deployment, not a port forward on a laptop install.

For BYOC, the app and the data stay in your infrastructure, and the access checks travel with the ontology wherever it is deployed. The open-source HelixDB build can run in memory, on disk, or against S3-compatible object storage as a startup flag, so in a self-run setup the storage backend is your choice.

Can you run models and inference yourself, and what does Foundry send to a model?

Yes. Foundry can work with self-hosted models, your own inference, or a model you bring yourself. If your policy forbids sending company data to a third-party model, point Foundry at inference you run. For a walkthrough with local models, see Build an Ontology With a Local LLM: Ollama and LM Studio.

Know exactly what leaves the app when a model is involved. Decide per deployment whether the model endpoint sits inside your boundary.

The ontology agent also proposes rather than commits. It drafts, and you review and load the result. Foundry never writes back to your sources, whichever model you choose.

Who sees which facts: RBAC, directory sync and source-grounded access

A user sees only what is grounded by sources they can read. That is the rule, and it works because every fact and relationship in the ontology is grounded in a source. If you cannot see a source, you cannot see anything in the ontology grounded by it.

This answers the problem that joins create. An ontology merges records from many systems, and a join can reveal what no single source reveals. Foundry closes that gap by enforcing access at retrieval time, as the requesting user, using permissions that trace back to the sources. The longer treatment is in Ontology Access Control: Who Sees What Your Agents Know.

The moving parts, as the docs describe them:

  • Directory sync: people and groups can sync via enterprise directory sync, so access can be assigned to members and teams.

RBAC and directory sync are on by default, and access to the sources and the ontology is authenticated. The honest limit: source-grounded access is only as fine-grained as your sources. If one table mixes data that different people should see, the boundary is the table. Check that the grants match how your sources are actually split.

What the docs do not specify, and the checks to run before sign-off

The Foundry documents state that data is encrypted at rest on object storage. They do not specify the items below, so confirm each for your deployment rather than assuming.

  • Encryption algorithm and key length.

  • Key management: who holds the keys, rotation, and whether customer-managed keys are supported.

  • Compliance attestations that apply to a specific Foundry deployment as opposed to the wider HelixDB Cloud service.

  • Network controls for a BYOC deployment, such as private endpoints and egress rules. These depend on your cloud account, not on Foundry.

Then run these checks:

  1. Deploy a test instance with a bucket you control and confirm in your cloud console that the objects are encrypted and which key is in use.

  2. Create two members with different source grants and ask the same question as each. Confirm the restricted member gets no fact grounded in a source they cannot read.

  3. Connect an agent through the MCP as a restricted user and confirm it inherits that user's limits.

  4. Decide where model inference runs, and capture the generation payload described above in your data protection record.

  5. Confirm nobody can reach the HelixDB instance directly. The database has no per-user permissions, so a direct connection would bypass Foundry's app-level checks.

Reviewers skip the fifth check most often. Lock down network access to the database so the only path to the data is through Foundry.

Run it in your own account and test the boundary yourself

Foundry gives you a stored ontology that is encrypted at rest on object storage, a deployment you can keep in your own account, models you can host yourself, and access that follows source permissions. It leaves key management and attestation details for you to confirm. The fastest way to settle the open items is to run it. Clone the helix-foundry repo, start it with Docker Compose, then repeat the five checks above against a BYOC test deployment before you put joined company data in it.

Build with HelixDB

Give your coding agent the setup prompt, or sign up and deploy a database.

Sign up