Cloudsmith now governs which skills your coding agent loads. What governs what that skill deploys to production Kubernetes?
Cloudsmith launched an AI Agent Skills registry at KubeCon on 9 November 2026 to control which skills an agent can pull. A vetted skill still runs with the agent's access, so here are the five runtime controls that decide what it can deploy to production Kubernetes: scoped credentials, policy, approvals, environments and audit attribution.
Cloudsmith's AI Skills registry, launched at KubeCon on 9 November 2026, governs what an agent loads. It hosts versioned skills, proxies public sources like GitHub, applies version-aware policy and allow or deny lists, and logs every pull (Cloudsmith).
A vetted skill still acts with whatever access the agent holds. Cloudsmith's own launch post says a bad skill can cause harm "using the access the agent already has." The registry decides which instructions run. Credentials and policy decide what those instructions can change.
Five runtime controls govern what reaches production: a scoped credential per agent, policy evaluated on every request (OPA at the API, Kyverno or ValidatingAdmissionPolicy at admission), human approval for production, separate environments, and an audit log that names the agent.
Neither layer records the other. Kubernetes audit events do not know which skill version drove an action, and the registry does not know what the agent did next. You join them through a per-agent identity and a timestamp.
With Qovery, agents deploy through an API, never a kubeconfig. Each agent can get an API Policy Token with a Rego policy, its actions appear in the audit log as policy:<token-id>:<token-name>, and the Qovery MCP Server is read-only by default.
I wrote our launch post for API Policy Tokens, so when Cloudsmith announced its skills registry I read it with one question in mind. Say the registry does its job perfectly and the skill your agent loads is exactly the version your security team approved. What stops that skill from scaling your production API to zero replicas?
The registry cannot answer that, and it does not claim to. This article covers the other half: the runtime controls that decide what a vetted skill can do to a production Kubernetes cluster.
What did Cloudsmith announce at KubeCon?
Cloudsmith announced AI Agent Skills registry support on 9 November 2026, during KubeCon + CloudNativeCon North America in Salt Lake City (Cloudsmith press release, Cloud Native Now). It treats skills as one more artifact type in Cloudsmith, next to packages and containers, and it is available now to Cloudsmith customers.
The press release lists five capabilities:
A skills package type to host and cache versioned skills, meaning a SKILL.md plus its supporting files.
An upstream proxy that serves public skill sources through the registry.
Built-in policy support for version-aware access to skills.
Allow and deny lists to permit or block skills by name and version.
Logging of skill access and usage through existing observability tools.
Cloudsmith's launch blog post adds the mechanics. You add a GitHub repository as an upstream with a token, Cloudsmith caches its skills and Claude plugins, and a deny rule blocks a specific skill or version so pulls return "nothing found."
Alison Sickelka, VP of Product at Cloudsmith, framed the problem this way: "Enterprises can't say who published a skill, which version their agents are running, or whether anyone approved it, and an agent will act on whatever that file tells it to do" (Cloudsmith).
Cloudsmith is not alone here. JFrog launched a Skills Registry with scanning and signing in March 2026 (JFrog). Skills are becoming packages, and package managers are adding them.
Why do agent skills need supply-chain control at all?
Agent skills need supply-chain control because they are code and instructions from strangers that an agent executes with your credentials, and the public catalogs have already been poisoned. The numbers from early 2026 are bad enough to justify a registry on their own.
Snyk's ToxicSkills audit scanned 3,984 skills from ClawHub and skills.sh on 5 February 2026. 1,467 (36.82%) had at least one security flaw, 534 (13.4%) had a critical issue, and Snyk confirmed 76 malicious payloads (Snyk).
Koi Security's ClawHavoc research found 341 malicious skills out of 2,857 on ClawHub, 335 of them from a single campaign that installed the Atomic Stealer macOS malware. A 16 February update counted 824 malicious skills as the marketplace grew past 10,700 (The Hacker News).
The barrier to publish was low. Snyk noted that publishing on ClawHub required a SKILL.md file and a GitHub account one week old, with no code signing or security review (Snyk).
A registry with an upstream proxy and deny lists addresses exactly this. Your agents stop pulling from a public catalog directly, someone reviews a version before it is allowed, and a skill that turns out to be malicious can be blocked everywhere at once.
What does a skills registry control, and what does it leave open?
A skills registry controls what an agent can load: which skills exist, which versions are approved, and who pulled what. It does not control what the agent does after loading the skill, because the skill runs inside the agent, and the agent acts with its own credentials. Cloudsmith's launch post says it plainly: a skill that is "malicious, changed, or simply wrong can cause an agent to leak data, run harmful commands, or take actions no one intended, using the access the agent already has" (Cloudsmith blog).
Question
Answered by the skills registry
Answered by runtime controls
Is this skill from a source we trust?
Yes, upstream proxy and allow lists
No
Is this the approved version?
Yes, version-aware policy
No
Which agents pulled this skill, and when?
Yes, pull logs
No
Can we block a skill everywhere today?
Yes, deny lists
No
Can this agent deploy to production?
No
Yes, credential scope and policy
Can this agent read production Secrets?
No
Yes, RBAC and policy
Does a human approve this production change?
No
Yes, approval gates
Which agent made this change, for which human?
No
Yes, per-agent identity in the audit log
What happens when an approved skill has a bug?
No
Yes, blast radius set by scope and environment
The last row is the one I worry about most. A malicious skill is the headline risk, but an approved, well-meaning skill that does the wrong thing confidently is the one a registry will happily serve: a "clean up unused resources" skill that decides production looks unused, or a deploy skill that picks the wrong kube context. A registry approves provenance and versions, and every action the agent takes afterwards falls outside it.
Once a skill is vetted, what actually governs what it can deploy?
Five runtime controls govern what a vetted skill can deploy to a production Kubernetes cluster: the credential the agent holds, the policy evaluated on each request, the approval required for production, the environment boundary, and the audit trail that names the agent. Each one works regardless of which skill is loaded, which is why they belong to a different layer than the registry.
1. A scoped credential per agent
The credential sets the ceiling. Whatever the skill says, the agent cannot do more than its token allows, so give each agent its own short-lived identity with the smallest scope that does the job.
On raw Kubernetes, that means one ServiceAccount per agent, tokens issued through the TokenRequest API with an expiry measured in hours, and a namespaced RoleBinding that starts at view (Kubernetes service accounts). Never hand an agent a cluster-admin kubeconfig from someone's laptop. Ten agents sharing one credential are also ten agents you cannot tell apart later, a problem Morgan covered in detail in our post on agent attribution and audit trails.
2. Policy evaluated on every request
RBAC decides which verbs an identity has on which resources. Policy decides whether this specific request, with this body, is acceptable. You need both, and policy can sit at two places.
At the API in front of the cluster. A platform or gateway evaluates an OPA (Rego) policy on each call: which environment, which service, which action, which HTTP method, what is in the body.
Here is a ValidatingAdmissionPolicy that refuses any create, update or delete of Deployments from identities in an agents group, in namespaces labelled env: production:
YAML
apiVersion: admissionregistration.k8s.io/v1
kind: ValidatingAdmissionPolicy
metadata:
name: agents-no-direct-prod-writes
spec:
failurePolicy: Fail
matchConstraints:
resourceRules:
- apiGroups: ["apps"]
apiVersions: ["v1"]
operations: ["CREATE", "UPDATE", "DELETE"]
resources: ["deployments", "deployments/scale"]
validations:
- expression: "!request.userInfo.groups.exists(g, g == 'agents')"
message: "AI agents cannot change production Deployments directly. Open a PR or use the approved deploy path."
---
apiVersion: admissionregistration.k8s.io/v1
kind: ValidatingAdmissionPolicyBinding
metadata:
name: agents-no-direct-prod-writes
spec:
policyName: agents-no-direct-prod-writes
validationActions: ["Deny"]
matchResources:
namespaceSelector:
matchLabels:
env: production
This only works if agents carry a distinct identity (control 1). Policy cannot tell an agent apart from a human who uses the same credential.
3. Human approval for production
Approval gates put a person between the agent's intent and production. The agent can prepare the change, a human reviews the diff, and only an approved change ships. The common forms are a pull request reviewed by a code owner, a GitOps sync from a protected branch, or deployment protection rules such as required reviewers on a GitHub Actions environment.
The approval has to be enforced by credentials and policy, or the agent can skip it. If the agent holds a token that can write to production directly, the PR is a suggestion.
4. Separate environments with separate permissions
Environments limit the blast radius of an approved skill with a bug. Let agents write freely in a preview or staging environment, and promote to production through the approval path. A preview environment per pull request gives the agent a full copy of the stack to break, and its credential never reaches production.
Put the boundary in permissions. Separate namespaces with separate RoleBindings is the minimum; separate clusters or cloud accounts for production is better.
5. Audit attribution that names the agent
The audit trail answers "which agent did this, on whose behalf, under which policy" after the fact. Kubernetes audit events record the authenticated credential (user.username, user.groups) and nothing about the agent, the model or the skill. Per-agent identity turns that credential into an agent name.
Then join the two logs. The registry's pull log knows that agent-claude-code-alessandro pulled [email protected] at 14:02. The cluster or platform audit log knows that the same identity scaled api in staging at 14:05. Neither knows both facts, so you match them on the identity and the timestamps. Without per-agent identity, that join is impossible.
Vet the skill. Then scope the agent.
Qovery API Policy Tokens put an OPA policy on every API call an agent makes, and the audit log records each action under the token's name, on Kubernetes in your own AWS, GCP, Azure or Scaleway account.
What happens when an approved skill does the wrong thing?
Here is a scenario I walk teams through. A platform team approves [email protected] in its skills registry. The skill tells the agent to deploy a service and then "scale down any replicas that are not serving traffic" to save cost. During a quiet hour, production gets almost no traffic.
Setup
What the agent does
Outcome
Registry only, agent holds an admin kubeconfig
Deploys, then scales production api to 0
Outage. Audit log shows the kubeconfig's identity, shared with a human
Registry plus per-agent ServiceAccount with view on production
Deploys to staging, scale on production is forbidden
Staging changes, production untouched, the forbid decision is logged under the agent's name
Registry plus admission policy on agents group
Scale on production denied at admission with a clear message
Agent reports the denial back to the human
Registry plus brokered API with a policy token scoped to staging deploys
Deploy call allowed, scale call on production rejected by the policy
Rejection attributed to the named token in the platform audit log
Registry plus PR approval for production
Agent opens a PR with the scale change
A reviewer sees "replicas: 0" on production and rejects it
The registry did its job in every row, and the skill was approved and unchanged. The runtime setup alone decided the outcome.
Which approach should you combine with a skills registry?
Combine the registry with at least one control from each runtime column: identity, policy and approval. This table compares the common ways teams give agents deploy access, judged on the controls above.
How do the supply-chain layer and the runtime layer work together?
The two layers work together when they share an identity and a source of truth for policy. A practical setup I recommend:
One identity per agent, used everywhere. The same name in the registry pull logs, the platform token name and the Kubernetes ServiceAccount.
Approved skill versions and runtime policies reviewed together. When security approves [email protected], they also check which token policy the agents running it hold.
Deny at both layers during an incident. Block the skill version in the registry and revoke or tighten the agent's token. The first stops new pulls; the second stops agents that already loaded it.
Policy as code in Git. Rego policies, admission policies and skill allow lists all go through review, with history.
During an incident, do both. Skills already loaded into a running agent session do not disappear when you deny them in the registry. The credential revocation is what stops a session in progress.
Where does Qovery fit, and where doesn't it?
Qovery governs the runtime side: what an agent can deploy and operate on Kubernetes in your own cloud account. It does not replace a skills registry. Qovery is an Agentic DevOps platform that deploys and operates apps on Kubernetes in your own AWS, GCP, Azure or Scaleway account, or on a Kubernetes cluster you already run. Agents call the Qovery API instead of holding a kubeconfig.
For the five runtime controls, this is what Qovery provides:
Scoped credentials.API Policy Tokens (in Preview) carry no role. Each holds an OPA policy written in Rego, evaluated on every request and failing closed, based on the action, the target resource, the HTTP method and the request body. I described the design in our launch post.
Policy. The same Rego policy is the per-request check, so "deploy the api service in staging, nothing else" is one policy, and revocation takes effect immediately.
Environments. Projects and environments with RBAC, and a preview environment per pull request, so agents iterate on a copy of the stack.
Audit attribution. Actions taken with a policy token appear in the Qovery audit log as policy:<token-id>:<token-name>, so an agent's activity is distinguishable from a human's or a CI token's.
Read-only by default. The Qovery MCP Server is read-only unless you connect it with write access explicitly and enable write access in the Qovery Console.
On the supply-chain side, Qovery Agent Skills (qovery-deploy, qovery-troubleshoot, qovery-preview and others) are skills Qovery publishes itself. If your policy says agents only load skills that someone reviewed, review them like any other skill and pin the version you approved. I have not tested mirroring them through Cloudsmith, so I won't claim it works out of the box. Whichever way you install them, the runtime layer above applies the same way, because the skills call the Qovery API with the agent's credential.
The agentic infrastructure hub collects our other articles on running agents against real infrastructure.
How do I set this up with Qovery from Claude Code or Cursor?
Install the Qovery Agent Skills, connect the MCP Server read-only, and only add write access when you have decided what the agent may change.
BASH|1. Qovery Agent Skills for Claude Code, Cursor, Codex, OpenCode, Gemini CLI
curl -fsSL https://skill.qovery.com/install.sh | bash
# 2. Or scoped to the current project instead of globally
curl -fsSL https://skill.qovery.com/install.sh | bash -s -- --project
# 3. MCP Server for Claude Code over OAuth, read-only by default
claude mcp add --transport http qovery https://mcp.qovery.com/mcp --callback-port 4242
# 4. Write access, only when explicitly wanted (also needs write access enabled in the Qovery Console)
claude mcp add --transport http qovery "https://mcp.qovery.com/mcp?read_write=true" --callback-port 4242
Your agent asks you to approve each install command. The MCP Server opens an OAuth login in your browser and acts with your own user permissions. The project-scoped install (command 2) keeps the skills in the repository, which makes them easier to review and pin.
For an autonomous agent that should not act as you, ask in plain language: "create a Qovery API Policy Token that can only deploy the api service in the staging environment". The qovery-policy-token skill writes the Rego policy, tests it and creates the token, and you review the policy before it exists. Then ask the agent to "deploy this branch to staging with Qovery" and check the audit log entry under the token's name. Setup details are in the AI agent quickstart and on the Claude Code integration page.
Frequently asked questions
What did Cloudsmith launch at KubeCon North America 2026?
Cloudsmith launched AI Agent Skills registry support on 9 November 2026, at KubeCon + CloudNativeCon North America in Salt Lake City. It adds a skills package type for versioned SKILL.md bundles, an upstream proxy for public sources such as GitHub, version-aware policy, allow and deny lists by name and version, and logging of every pull. It is available to Cloudsmith customers now.
Once a skill is vetted, what actually governs what it can deploy to your production Kubernetes cluster?
The agent's runtime controls govern it: the credential the agent holds, the policy evaluated on each request, human approval for production, environment separation, and an audit log that names the agent. A vetted skill runs with whatever access the agent has, so a scoped, per-agent credential with an OPA, Kyverno or ValidatingAdmissionPolicy check is what stops it from changing production. The registry decides which skill loads; these controls decide what it can do.
Does a skills registry stop prompt injection or a buggy skill?
A skills registry reduces the chance of loading a malicious or tampered skill, through allow lists, version pinning and blocking. It cannot stop an approved skill from doing something harmful at runtime, whether because of a bug or because the agent read injected instructions from a file or web page. Scoped credentials and per-request policy limit the damage in both cases.
Can Kyverno or OPA Gatekeeper restrict what an AI agent deploys?
Yes, if the agent has its own identity. Kyverno, OPA Gatekeeper and ValidatingAdmissionPolicy can match on the requesting user or group and deny changes in production namespaces, or require approver annotations. If agents share a credential with humans, admission policy cannot tell them apart.
How do I know which skill version caused a production change?
Join the skills registry pull logs with your cluster or platform audit log, using the agent's identity and the timestamps. Kubernetes audit events record the credential but not the skill or model. This join only works when each agent has its own identity, used in both places.
Does Qovery replace a skills registry like Cloudsmith?
No. Qovery governs what agents can deploy and operate on Kubernetes in your own cloud account, through API Policy Tokens with OPA policies, environments, RBAC and an audit log that attributes each action to the token. A skills registry governs which skills agents can load. Teams that care about both run both.
Alessandro leads product at Qovery. He drives the changelog, roadmap, and product strategy - turning customer feedback into platform capabilities.
Next step
Vet the skill. Then scope the agent.
Qovery API Policy Tokens put an OPA policy on every API call an agent makes, and the audit log records each action under the token's name, on Kubernetes in your own AWS, GCP, Azure or Scaleway account.