How to Configure Continue Kubernetes Permissions
You set up continue kubernetes permissions by binding a dedicated Kubernetes Role to the client identity. This setup restricts what cluster objects the AI coding assistant can read or change. Many teams start by letting the assistant use a developer's local cluster context. When that user holds broad admin rights, the AI assistant inherits those same wide rights. A bad prompt or model mistake can then delete pods or read secret keys across namespaces. How native continue kubernetes permissions
Your coding agents run with your access.
Claude Code reaches prod with a developer's credentials, and approval prompts get clicked through. hoop.dev checks every query, masks sensitive data, and holds risky changes for a human.
You set up continue kubernetes permissions by binding a dedicated Kubernetes Role to the client identity. This setup restricts what cluster objects the AI coding assistant can read or change. Many teams start by letting the assistant use a developer's local cluster context. When that user holds broad admin rights, the AI assistant inherits those same wide rights. A bad prompt or model mistake can then delete pods or read secret keys across namespaces.
How native continue kubernetes permissions work
Continue runs on the developer's machine and calls tools or commands using local user credentials. When it interacts with a cluster, the Kubernetes API server checks those credentials against RBAC rules. In Kubernetes RBAC, a Role or ClusterRole holds a list of rules that grant permissions. These permissions are purely additive, which means there are no deny rules in the system.
A Role always sets permissions inside a single namespace. A ClusterRole is not tied to one namespace and can cover cluster-wide objects like nodes. It can also cover namespaced resources across every namespace in the cluster. To grant these permissions to the identity that Continue uses, you create a binding.
A RoleBinding grants permissions inside one namespace and can point to a Role or a ClusterRole. A ClusterRoleBinding grants access across the whole cluster. For a safer setup, teams create a specific service account or user identity for the assistant. They then bind a narrow Role to that identity in a test or dev namespace.
You also need to control subresources when you set up these rules. RBAC names resources the same way they appear in the API URL. Subresources like pod logs or pod exec sessions use a slash in the resource name. If you only want Continue to read pod status and logs, you grant read rules on pods and the log subresource. You leave out the exec subresource so the assistant cannot run shell commands inside containers.
What native RBAC solves and what stays exposed
Native Kubernetes RBAC solves the problem of who can talk to the API server. It blocks unauthorized identities from touching namespaces or resource types outside their assigned Role. By separating the assistant's Role from the human admin Role, you reduce the blast radius of mistakes. You can limit the assistant to read-only actions on pods and deployments in one namespace.
Kubernetes RBAC + AI Agent Permissions: architecture patterns and best practices
Continue reading? Get the full guide.
Free. No spam. Unsubscribe anytime.
Still, native RBAC only checks the resource type and the action verb at the API gate. It does not inspect the contents of what comes back or what runs inside an allowed session. If a Role allows reading pod logs, the API returns the full log stream to Continue. Those logs often contain customer emails, phone numbers, credit card numbers, or national IDs.
Once the API server sends that response, the raw text goes straight into the model prompt. The same gap happens when a developer gives Continue permission to use the pod exec subresource. RBAC allows the exec call to start, but it cannot check the shell commands sent inside that stream. It also cannot require a human to approve a single risky command while allowing safe read commands.
Govern kubectl and API calls in flight
Identity providers and Kubernetes RBAC decide who logs into a cluster. They cannot redact keys inside returned JSON objects or hold a risky delete call for review. By design, hoop.dev runs as an open-source proxy, a sidecar for your Kubernetes API, checking requests and responses without replacing RBAC.
First, hoop.dev guardrails refuse banned methods, paths, or headers before they run. Next, hoop.dev data masking rewrites sensitive keys in returned Secret, ConfigMap, and log responses in memory, and writes each decision to the audit trail. Explore the repo on GitHub.
Frequently asked questions
Can I add a deny rule to block Continue from reading Secrets?
No, Kubernetes RBAC rules are purely additive and do not support deny rules. To block access to Secrets, you must omit Secret resources from every Role bound to that identity.
Should I use a RoleBinding or a ClusterRoleBinding for an AI coding assistant?
Use a RoleBinding in a specific namespace whenever possible. A ClusterRoleBinding grants rights across all namespaces, which exposes more workloads if the assistant makes an unintended call.
How do I let Continue read pod logs without allowing container shell access?
Grant get and list verbs on pods and the pod log subresource in your Role. Do not include the pod exec subresource in the rule list for that Role.
Related guides
In this post