How secrets are handled
Secret values are write-only. You can set them and rotate them. Nothing reads one back — not a page, not an endpoint, not a log, not an audit row, not an error message, not an export.
This includes reading them back to you. It is not an access-control setting, and there is no administrator who can turn it off.
Where the refusal is enforced
Section titled “Where the refusal is enforced”In the shared pure code, applied in two places: in the agent before anything is serialised onto the wire, and again on the server.
That ordering is the point. A compromised Seylo server cannot ask an agent for a Secret value, because the agent strips it before it ever becomes a message.
What you see instead
Section titled “What you see instead”Key names, always. An environment variable sourced from a Secret shows the Secret and the key it comes from, so you can tell what a workload consumes without seeing what it consumes.
In the resource browser, Secrets are listed through the API server’s metadata-only content negotiation, and any value is stripped in shared code before it could be serialised.
Setting and rotating
Section titled “Setting and rotating”Values can be set and rotated through the normal propose-and-approve flow. On the way:
- A typed value is AES-256-GCM encrypted into the approval payload.
- It is decrypted in memory at apply time.
- The ciphertext is scrubbed from the request afterwards.
- The manifest version, the git export and the audit log record key names with a withheld placeholder — never the value.
A canary check in our test suite greps every database table for a known test value, in plaintext and base64, and requires zero hits. It runs on every build.
Copying a namespace
Section titled “Copying a namespace”Copying a namespace copies its Secrets too,
because the copy will not start without them. The plan reads every key name
of every Secret. It reads no value, and none is shown. You choose, per key, to
carry the value over (carry-over), type a new one (new-value), create the
key empty (blank) or leave it out (skip).
The plan also checks that every key a copied workload reads will exist in the
target. A key you set to skip that a workload reads blocks the plan, because
the pod would fail with CreateContainerConfigError. After the apply, Seylo
reads each Secret back by key name only.
Carry over is the default where it is possible. How the value travels depends on how Seylo reaches the two clusters:
- From a cluster Seylo reaches directly: the server reads the source value when the copy is applied and writes it straight into the target. It is held in memory for that moment and stored nowhere.
- Within one cluster that runs the Seylo agent (0.2.3 or later): the agent reads the source Secret and writes the copy inside your cluster. Seylo receives the key names, never the values. The agent does this only between namespaces it already manages, where a workload could mount either Secret anyway.
- Between two clusters that each run the agent: carry over is not available. The value would have to leave the source cluster, and the agent never sends one. Type the new value or leave the key blank, and the copy tells you which keys need it.
A value you type is encrypted into the approval request, as when setting a value, and scrubbed from the request after the apply, whether the copy succeeded or not. The approver sees key names and your choice for each, never a value.
By default, values held in a key vault are not copied at all. A SecretProviderClass is copied as a definition, and the pods fetch the values from the vault themselves. If they authenticate with Azure workload identity, the target namespace needs a federated credential in Azure. Seylo holds no Azure credentials, so it gives you the command to run instead. See Azure Key Vault and workload identity.
ServiceAccount tokens, Helm release records and cert-manager certificates are not copied: the target cluster issues its own.
Converting Key Vault (CSI) secrets in a copy
Section titled “Converting Key Vault (CSI) secrets in a copy”A copy can instead convert an Azure Key Vault SecretProviderClass into an ordinary Kubernetes Secret, so the copy runs on a cluster without the Secrets Store CSI driver. It is off by default, and you opt in per SecretProviderClass, per copy, by choosing Convert to a Kubernetes Secret instead of Keep Key Vault (CSI).
The write-only rule holds throughout. Seylo does not read Key Vault, does not exec into a pod, and never reads a value out of your cluster. Each value either:
- is carried in-cluster: the agent copies it from the Kubernetes Secret the SecretProviderClass syncs in the source, inside one cluster. It never reaches Seylo; or
- is entered by you, write-only, encrypted into the approval request and
scrubbed after the apply, like any
new-value.
The workloads are switched to a secret volume at the same mount paths.
Converting changes where the values live, and the wizard says so before you can accept it:
Converting a Key Vault (CSI) SecretProviderClass to a Kubernetes Secret makes the copy a SNAPSHOT: the values are written once, so a rotation in Key Vault will NOT reach it. Key Vault's access policies and its audit log no longer apply to these values - they live in the target cluster's Secret store, where anyone with read access to Secrets in that namespace can read them, and whether they are encrypted at rest depends on that cluster's configuration (etcd encryption / a KMS provider). Recommended for dev/test copies, not for production.The copy cannot be submitted until you tick I understand: this copy is a snapshot. Key Vault rotations will not reach it, and its values live in the target cluster’s Secret store. The approver sees the same warning, and key names only.
Conversion is not available to coding-agent tokens. Full steps: convert Key Vault secrets to Kubernetes Secrets.
Where RBAC, not code, is the boundary
Section titled “Where RBAC, not code, is the boundary”The write-only guarantee is about values, and it is enforced in code. The agent’s Kubernetes token can read Secrets.
Tier 1, on by default, grants get, list, create, update, patch and
delete on Secrets. On the default cluster-wide install that covers every
Secret in every namespace, kube-system included, not only the namespaces
Seylo manages. Seylo uses it to set and rotate values, to apply Secrets in
releases, provisioning and namespace copies, to carry a value over inside your
cluster, and to show Secret key names in the environment view. Values are
stripped in the agent before serialisation and again on the server, so none is
ever shown.
The implication, stated plainly: anyone able to replace the agent’s image could read every Secret that token reaches.
If that is in your threat model:
- Install namespace-scoped (
rbac.scope=namespaced, with the namespaces inwatchNamespaces). The token then reaches Secrets only in the namespaces you list. This is our recommendation for regulated clusters. - If you enable the resource browser’s generic read, prefer
enumeratedmode.wildcardmode also reads Secrets;enumeratedadds no Secret read of its own. - To remove tier 1’s Secret rule entirely, set
rbac.write.tier1.enabled=false. Setting, rotating and carrying over Secrets through Seylo then stop working.
See Secrets in the default grant.
Pod logs
Section titled “Pod logs”Streamed to your browser and stored nowhere — no table, no manifest version, no operation event, no audit detail.
The audit trail records who read which pod’s logs, with which options, never the content.
Application logs routinely contain credentials the application printed. Seylo does not persist them; retain them in your cluster’s own log pipeline where your retention and access rules apply.
Why a tool argument counts as disclosure
Section titled “Why a tool argument counts as disclosure”When Seylo exposes tools to a coding agent, no tool accepts a Secret value as an argument. A tool argument is a transcript entry, and a transcript is readable, forwardable and often retained by a third party. Accepting a secret value as an argument discloses it as thoroughly as returning one would.
Instead, a tool requests that a secret be supplied through the approval flow, where the value goes to the cluster and to nowhere else.
The same holds for values that only look like a secret. A ConfigMap value, or
a value in a deploy call’s env, that looks like a password, key or token is
refused, and the refusal names the variable, never its value. The agent is told
to call request_secret and to read the Secret through a secretKeyRef.
Container exec
Section titled “Container exec”There is no interactive shell into your containers, and no attach, at any setting: a shell in a container reads Secret values trivially, and no amount of policy above it changes that.
What exists instead is opt-in per cluster and off by default: commands in containers, a fixed list of read-only commands Nightshift, Seylo’s AI SRE, may run while it troubleshoots. It keeps Secret values where they are:
- paths under
/var/run/secrets,/run/secrets,/rootand/home, and any path whose name suggests a credential, are never read; envreturns variable names only;- output is redacted inside your cluster before it leaves, and again on Seylo’s server.