Security and compliance
How BullSequana AI provides identity, isolation, audit evidence, and sovereign operation.
BullSequana AI applies security controls across the full platform rather than adding them separately to each AI or Data service. The product provides shared identity, authorization, tenant isolation, secret handling, encrypted service exposure, and operational evidence through Foundation services.
This page describes product behavior first, then identifies the settings that administrators control for their environment.
Identity and access
BullSequana AI centralizes authentication and identity federation through Keycloak. Platform services use the same sign-in boundary, and SSO-enabled components are enrolled automatically from declarative configuration. OpenFGA adds relationship-based authorization where a service needs permissions beyond role membership. Only platform services holding their own key can query or change OpenFGA.
The administration model distinguishes several scopes:
| Scope | Product behavior |
|---|---|
| Platform | Controls installation-wide settings and tenant lifecycle, and bounds each tenant: its GPU guarantee and cap, compute quota, deployment policy, model publishing, and monthly BCU allowance. |
| Tenant | Isolates one customer or organization and delegates administration within that boundary. |
| Group | Groups members and service accounts inside a tenant for roles, model allow rules, BCU caps, and API-key funding. |
| Service account | Gives automation in one tenant its own client credentials, roles, groups, and owners. |
Tenant administrators connect the approved identity provider, manage group membership and service accounts, delegate roles, and revoke access. Platform operators manage the underlying identity, authorization, and secret services.
Use Administration and operations for role boundaries and Roles and permissions for every operation permission. Use Keycloak, OpenFGA, and External Secrets for implementation detail.
Model access and API keys
Calling any model, a language model or a predictive model, needs a Can use allow rule in the caller's organization. Only the model's owner calls it without one, while a member of the organization that owns it. Rules apply to Portal sessions and API keys alike, and removing a rule stops new calls at once. A model without a rule for the caller cannot be called and is left out of model pickers and the BSQAI API model list. See Model access.
A tenant can offer a language model it deployed to every tenant only after a platform administrator allows it to publish. Each receiving tenant still decides with its own allow rules which of its members may use the model. Other tenants see only the model, never its deployment.
API keys are personal and bound to one tenant. Each key carries an immutable permission scope, chosen at creation, that never exceeds the owner's current access: every request needs both the key's scope and the owner's current authorization. Credential, Skill, data-ingestion, identity-provider, and most tenant-administration permissions can never be placed in a key. A key is also bound to the group that funds its calls, which a BCU cap can limit. See API credentials.
Service accounts give automation its own identity in one tenant. Tenant administrators create and delete them, and the owners of each account decide who may act as it. See Manage service accounts.
Every model call passes these checks in the BSQAI API before it is forwarded. A call to an in-cluster model then goes through the internal inference gateway; a call to an external provider connection leaves the cluster from the BSQAI API.
Calls to Connectors pass through the MCP Gateway, which authenticates the caller, checks that the server belongs to the caller's organization, and applies the server's tool allowlist.
Tenancy and isolation
Multi-tenancy is a BullSequana AI product capability. Each tenant represents a customer-level isolation boundary. Groups provide a second access tier for departments and working groups inside that tenant.
Product services carry the tenant and group context into applications, Data workspaces, model access, pipelines, artifacts, and administrative views. Authorization limits which resources a user or service identity can discover and operate. Data workspaces add viewer, editor, administrator, and pipeline-runner roles instead of giving every collaborator the same permissions.
Administrators select the tenant and group structure, assign memberships, and configure delegated access. BullSequana AI supplies the isolation and policy mechanisms that enforce those choices.
Core concepts defines the hierarchy. Multi-tenancy and tiered access in Data explains how the model is enforced in Developer Workspace.
Tenant runtime isolation
Each tenant runs in its own Kubernetes namespace, tenant-<slug>, which the tenant operator creates and reconciles:
- Quota. A ResourceQuota caps the CPU, memory, and storage the namespace may use, and a LimitRange gives every container a default request and limit. Platform administrators set the quota.
- Network boundary. With the platform's network policies enabled, which is the default, a default-deny policy admits only traffic between pods of the same namespace. The tenant's model workloads, Managed MCP Servers, and private MLflow run in that namespace under their own, narrower policies: model workloads accept traffic only from the internal inference gateway and metrics collection, Managed MCP Servers only from the MCP Gateway, the BSQAI API, and the MCP operator, and private MLflow only from the BSQAI API. Other workloads of the tenant cannot reach them directly.
- GPU queues. The tenant's GPU use is bounded by its own scheduling queues: a guarantee and a cap that platform administrators set. Cluster admission holds every GPU pod in the namespace to those queues.
- Deployment policy. Platform administrators set which models, serving runtimes, and resource profiles the tenant may deploy. Tenant administrators and members cannot widen it.
Outside tenant namespaces, Kubernetes network policies limit each platform workload to the callers and services it uses, and a site can add default-deny to every platform namespace. Only the BSQAI API workloads that call models reach the internal model gateway. See Network policies.
Network policies take effect only where the cluster runs an engine that enforces Kubernetes network policies. See Set a tenant's quotas, Set what a tenant may deploy, and Network policies.
Agent code sandbox
Where the site enables the agent sandbox, agents in Build chats, ordinary chats that create files, and the scripts of active Skills run code in an isolated workspace. The code comes from a model or from a Skill's author, so BullSequana AI treats it as untrusted.
Isolation. Each chat's workspace is a pod in the coreai-sandboxes namespace that runs in its own Kata Containers virtual machine on dedicated nodes, so it does not share the host kernel. The pod runs as a non-root user with all Linux capabilities dropped and no Kubernetes service-account token. Admission rejects any pod in that namespace that does not use the Kata runtime, mounts a token or Secret, or requests host access. A workspace is bound to one chat and its owner in one tenant, and is saved in that tenant's bucket. The sandbox controller reads cluster-wide but writes only in the sandbox namespace.
Outbound traffic. In the default internet mode, a workspace reaches TCP 443 on public IPv4 addresses and the cluster DNS. Private ranges, the shared address space 100.64.0.0/10, link-local addresses, which include cloud metadata endpoints, and multicast are excluded, so a workspace cannot reach cluster services or private networks. Code in the sandbox can therefore send anything it can read, such as files a member attached or imported from the library, to any public HTTPS service. A prompt-injected agent or a hostile Skill script can use that path. Services on public addresses stay reachable, including the platform's own hostnames when the gateway has a public address. In blocked mode a workspace has no outbound traffic. The sandbox does not use the platform proxy.
These restrictions hold only where the cluster runs an engine that enforces Kubernetes network policies.
Previews. App previews are served on separate hostnames and admit only a browser that redeemed a single-use ticket from the Portal. Only the Portal can embed a preview, and platform sign-in and session cookies are not forwarded to the app.
Controls and evidence. The site operator enables the sandbox and chooses the outbound mode for the whole site. A platform administrator can turn it off for every tenant, and a tenant administrator for their tenant; leaving it on is the tenant's acceptance of the outbound path. The BSQAI API writes one audit log line per sandbox action, with the tenant, chat, acting user and outcome, into the tenant's telemetry, and logs every change of the switches and settings with the acting user. See Code sandbox settings.
Audit and compliance evidence
Foundation observability centralizes metrics, logs, and traces from platform services. Identity, authorization, workflow, and application signals retain the context needed to explain platform activity and diagnose access decisions.
These signals support questions such as:
- which identity performed an action
- which tenant and group applied
- which application, data asset, model, or tool was involved
- which policy allowed or denied access
- where a workflow failed or changed state
Each tenant has its own Grafana Organization. Its log, trace, and metric queries pass through the telemetry query gateway, which validates the user's token and restricts every query to that tenant. On every query, the BSQAI API checks the user's current membership and permission in Keycloak again, so a removed member or a revoked permission stops the next query. Tenant members cannot sign in to their tenant's Grafana Organization in 2.0.0; see Grafana.
Customers control access to operational evidence and define retention, export, and integration with their existing audit or security tooling. Foundation observability and audit explains the signal path; the Foundation security model explains the underlying controls.
BullSequana AI also keeps usage records for every model request and every tenant API request that the BSQAI API handles, including the model calls made by background work such as deep research and document ingestion. A record holds:
- the tenant, the user or API key owner, the API key identifier, and how the request reached the platform
- the reported calling application, the model and its owning tenant
- the outcome, the latency and the token counts the model server reported
Tenant administrators, and members whose custom role grants tenant.usage.read, read these records as tenant-wide summaries in Review tenant usage. Every member reads their own usage in My usage and through the BSQAI API. No reader sees another tenant's users or API keys.
The same records feed monthly BCU allowances and caps. Caps are set by tenant administrators and by members whose custom role grants tenant.usage.budget_manage; API keys cannot hold it. A member reads only their own cap and the pooled BCU of the groups funding their own API keys. Platform administrators set each tenant's allowance and read its total BCU, never its users, API keys or groups. A reached cap refuses new requests based on the verified credential, not on headers the client sends.
It also records capacity: per interval, the GPU, by GPU class, and the CPU and memory that each tenant's running pods held, idle time included, priced in BCU. A capacity record holds the tenant, the resource, the quantity, and the BCU, and no workload content.
Usage and capacity records never hold prompts, responses, request bodies, credentials or request headers. They are stored in the BSQAI API's database in your cluster. Their retention is not configurable: records are kept with no automatic expiry, including after a tenant is deleted.
When the optional Kubescape component is deployed, it scans the workloads running in the cluster every day: their Kubernetes configuration against the NSA, MITRE, and CIS frameworks, and their container images for known vulnerabilities. Its findings stay in the cluster as Kubernetes resources. Platform operators with cluster access read them with kubectl; tenant roles do not include them, and there is no user interface. See Reading findings.
The Data authorization service also keeps its own durable audit log: every request it handles, success or failure, to a per-tenant Kafka topic. This log covers that service's own API only, not other platform services. A tenant administrator can grant a subject direct, read-only access to it without giving them any other platform permission. Authorization Events Audit walks through granting, consuming, and revoking that access.
Sovereignty and air gaps
BullSequana AI runs on customer-controlled infrastructure and supports disconnected operating models. Platform images, packages, models, and documentation can be delivered through approved private channels. Core operation does not depend on mandatory external telemetry, and usage exports remain customer-controlled.
The product separates software delivery from external internet access:
- Harbor provides a private image-delivery path.
- GitOps configuration keeps the installed state reviewable and reproducible.
- Local identity, storage, observability, and model services keep core workflows inside the controlled environment.
- The vLLM recipe catalogue is carried into a disconnected installation as an exported snapshot file.
- Backup and recovery procedures cover stateful platform services without requiring a public control plane.
Where the site enables the agent sandbox in the default internet mode, code that agents run can send data to public HTTPS services; see Agent code sandbox for the controls.
When Kubescape is deployed, its vulnerability scanning of running images needs outbound HTTPS access to grype.anchore.io, where it downloads its vulnerability database. Its configuration scanning runs without external access.
Customers provide the approved infrastructure, identity source, delivery channel, residency policy, and recovery objectives for their deployment. Use deployment environments, Harbor delivery, and backup and disaster recovery for those configuration paths.
Product controls and customer configuration
| BullSequana AI provides | Customers configure |
|---|---|
| tenant and group authorization boundaries | tenant structure, membership, and delegated roles |
| model allow rules, permission-scoped API keys, and service accounts | who may call each model, and which keys and service accounts exist |
| tenant namespaces with quotas, network policies, GPU queues, and deployment policies | each tenant's quota, GPU guarantee and cap, and what it may deploy |
| centralized identity and component SSO enrollment | corporate federation and authentication policy |
| platform secret and certificate mechanisms | approved secret sources, trust, and rotation policy |
| tenant-aware platform signals | evidence retention, access, and export destinations |
| private delivery and disconnected operation paths | registry, network, residency, and recovery policy |
| isolated agent code sandbox with per-site outbound mode and platform and tenant switches | whether the sandbox is enabled, its outbound mode, and which tenants keep it on |
For a role-oriented walkthrough, use Govern and administer.