<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[k8slens - Medium]]></title>
        <description><![CDATA[Lens is the only IDE you’ll ever need to take control of your Kubernetes clusters, and any applications and services running on top. It’s built on open source and free. This is the official blog of Lens community. - Medium]]></description>
        <link>https://medium.com/k8slens?source=rss----1074b70245e3---4</link>
        <image>
            <url>https://cdn-images-1.medium.com/proxy/1*TGH72Nnw24QL3iV9IOm4VA.png</url>
            <title>k8slens - Medium</title>
            <link>https://medium.com/k8slens?source=rss----1074b70245e3---4</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 04:13:08 GMT</lastBuildDate>
        <atom:link href="https://medium.com/feed/k8slens" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Argo CD Tutorial: From Installation to App of Apps and ApplicationSets]]></title>
            <link>https://medium.com/k8slens/argo-cd-tutorial-from-installation-to-app-of-apps-and-applicationsets-be83fd8d0d00?source=rss----1074b70245e3---4</link>
            <guid isPermaLink="false">https://medium.com/p/be83fd8d0d00</guid>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[kubernetes]]></category>
            <category><![CDATA[argo-cd]]></category>
            <category><![CDATA[lens-kubernetes-ide]]></category>
            <category><![CDATA[gitops]]></category>
            <dc:creator><![CDATA[Flavius Dinu]]></dc:creator>
            <pubDate>Fri, 18 Sep 2026 09:54:50 GMT</pubDate>
            <atom:updated>2026-09-18T09:54:50.189Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*KMXa3SWFb4vW2DwJZd9poA.png" /></figure><p>TL;DR</p><ul><li>Argo CD is a GitOps tool that keeps your Kubernetes cluster in sync with your Git repository, solving drift, auditability, and access control issues</li><li>To use Argo CD, there are four important concepts that you need to understand: applications, sync status, health status, and projects</li><li>The app of apps pattern enables you to bootstrap multiple applications from a single root manifest, while ApplicationSets enable you to generate applications from a template</li><li>Lens Kubernetes IDE now offers native Argo CD support, so you can easily see sync and health status and jump into managed workloads from a single place</li></ul><p>Your Git repository says one thing, and your Kubernetes clusters say another, and there is no easy way to tell which one is right. Someone in your team scaled a deployment by hand last week, someone else hotfixed an image tag, and nobody can trust the Kubernetes manifests anymore.</p><p>Argo CD solves this by making Git the single source of truth for your cluster, and in this article we will:</p><ul><li>Walk through installing Argo CD</li><li>Deploy real applications with the app of apps pattern</li><li>Break an application on purpose</li><li>And learn how we can scale the setup with ApplicationSets</li></ul><p>Don’t feel like reading? Watch the video instead:</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2FswwOZGh1qJg%3Ffeature%3Doembed&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DswwOZGh1qJg&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2FswwOZGh1qJg%2Fhqdefault.jpg&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/d5e66f4c0679582b2f0e4dc5a1708282/href">https://medium.com/media/d5e66f4c0679582b2f0e4dc5a1708282/href</a></iframe><h3>What is Argo CD?</h3><p>Argo CD is a controller that lives inside your Kubernetes cluster, and its only job is to watch Git repositories and make your cluster look exactly like them. Git becomes the source of truth, and the cluster becomes a reflection of it. If someone in your team makes a manual change, Argo CD picks that up and, depending on how you configure it, will put it back.</p><p>There are three big problems that Argo CD solves:</p><ul><li><strong>Drift</strong>: Argo CD continuously compares what’s running in your Kubernetes cluster with what is in Git and tells you the moment they diverge</li><li><strong>Auditability</strong>: Every change you make to your environment will be a commit, so who changed what, when, and why become questions you can easily answer</li><li><strong>Access</strong>: Your engineers don’t need cluster credentials to deploy; they just need push access to a repository, which massively reduces the number of engineers in your team that hold production keys</li></ul><h3>What are the most important Argo CD concepts?</h3><p>Before installing Argo CD, let’s take a look at the four ideas that make it click:</p><ul><li><strong>Application</strong>: This is a custom Kubernetes resource that says: take this repository, with this folder, at this revision, and then deploy it into this cluster inside this namespace. You should consider the application the unit of everything in Argo CD</li><li><strong>Sync status</strong>: Argo CD constantly diffs Git against your Kubernetes cluster. If it matches, the application is Synced; otherwise, it is OutOfSync. Syncing is the act of applying the Git state to your Kubernetes cluster</li><li><strong>Health status</strong>: Your Argo CD application can be perfectly in sync, but it can be unhealthy. Sync answers the question “does the cluster match Git?”, while health answers “does this thing actually work?”</li><li><strong>Projects</strong>: An AppProject is a boundary that controls which repositories applications can pull from, which clusters and namespaces they can deploy to, and what resources you can create. On a shared cluster, this is exactly what stops team A from deploying into team B&#39;s namespace</li></ul><h3>How to install Argo CD?</h3><p>For this example, I will use a minikube cluster in Lens Kubernetes IDE, but you can use any kind of Kubernetes cluster and plain kubectl. Argo CD installs like any other application: you create a namespace, and apply the official manifests:</p><pre>kubectl create namespace argocd <br>kubectl apply -n argocd -f https://raw.githubusercontent.com/argoproj/argo-cd/stable/manifests/install.yaml</pre><p>In less than a couple of minutes, you will see that Argo CD has been installed successfully, and all of your pods are running.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ZlmkgSgoDHe-l_kd-7FbWw.png" /></figure><p>If you are using Lens Kubernetes IDE, you will see a new entry in the cluster navigator for Argo CD once the CRDs are detected. You get a dashboard that shows your applications and projects, and there is a button there to open the Argo CD UI directly. At this point, you will simply see the default project with no applications yet.</p><p>Check out this video to learn more about how Lens Kubernetes IDE can help you with Argo CD:</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2FZAPcB9f3kaU%3Ffeature%3Doembed&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DZAPcB9f3kaU&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2FZAPcB9f3kaU%2Fhqdefault.jpg&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/9f912c3d0c9469102023c63ac535caf4/href">https://medium.com/media/9f912c3d0c9469102023c63ac535caf4/href</a></iframe><h3>How to deploy Argo CD applications with the app of apps pattern?</h3><p>For this example, I’ve already prepared some code examples that you can leverage, which are available here: <a href="https://github.com/flavius-dinu/k8s_manifests">github.com/flavius-dinu/k8s_manifests</a>.</p><p>There is one root application in the root-app.yaml file, and this one points to the apps directory:</p><pre>apiVersion: argoproj.io/v1alpha1<br>kind: Application<br>metadata:<br>  name: lensagents-demo-root<br>  namespace: argocd<br>  finalizers:<br>    - resources-finalizer.argocd.argoproj.io<br>spec:<br>  project: default<br>  source:<br>    repoURL: https://github.com/flavius-dinu/k8s_manifests.git<br>    targetRevision: main<br>    path: apps<br>    directory:<br>      recurse: true<br>  destination:<br>    server: https://kubernetes.default.svc<br>    namespace: argocd<br>  syncPolicy:<br>    automated:<br>      prune: true<br>      selfHeal: true<br>    syncOptions:<br>      - CreateNamespace=true</pre><p>When you deploy this, all of your applications from the apps directory will be deployed as well, so what you need to do is clone this repository and simply apply this manifest:</p><pre>kubectl apply -f root-app.yaml</pre><p>Now, because I have an issue with one of my apps, you will see an error in the Lens Kubernetes IDE dashboard as well:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*AgQRQhOO0xQPhpxXQcqlVA.png" /></figure><p>Now, if we go to GitHub and fix the error, in a couple of seconds Argo CD will pick it up, and it will sync it to the cluster. If you are impatient, you can actually do the sync manually as well, by clicking the Sync button under the applications inside the dashboard:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HYYvWic9BVLU0hZTSVZmnQ.png" /></figure><h3>How to log in to the Argo CD dashboard?</h3><p>If you are using Lens Kubernetes IDE, you can easily log in to the Argo CD dashboard by clicking the Open Argo UI button. The username is admin, and you will need to get the password from a Kubernetes secret.</p><p>In Lens K8S IDE, this is straightforward; you just head out to Config -&gt; Secrets -&gt; (add a filter on the argocd namespace) -&gt; click on the argocd-initial-admin-secret. In the end, you simply toggle a button to get the base64-decoded value of the password, and you can easily use that:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*59D_1dgE03BH4yVlfAehng.png" /></figure><p>Now, if we head over to the Argo CD UI, we can log in with these credentials and see all of our applications there as well:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*w8kGh-4d2MbQ1zddk70Ugg.png" /></figure><h3>How to scale up with ApplicationSets?</h3><p>The app of apps pattern solves bootstrapping, but the biggest problem with it is the fact that you need to write a separate Application manifest for every new application. For a couple of applications, this is perfectly fine, but if you think that you might need to create 50 similar applications across several environments, you will end up repeating the same repository, destination, and sync policy over and over again, with only a couple of values changing.</p><p>This is where an ApplicationSet is a better fit: it takes a template and a source of parameters, then generates the applications automatically. A common setup is a generator that walks the directories of your repository and creates one application per directory it finds.</p><p>Each matching directory will supply a name and a path, and the template supplies the common configuration. This means that if you add a new workload directory, Argo CD will be able to generate its application without needing to copy another YAML file. Whether the workload deploys immediately depends on the generated application’s sync policy.</p><p>The app of apps pattern will be useful for bootstrapping, and a root application can even deploy an ApplicationSet, but when you repeat the same application structure over and over, ApplicationSets remove a lot of that maintenance.</p><h3>What are the best practices for Argo CD in production?</h3><p>When it comes to using Argo CD in production, there are three things you need to consider:</p><ul><li><strong>Turn off the admin account</strong>: You should never use the admin account after you’ve started setting up Argo CD, because this will be a great security risk for your production environment. What you can do is wire up SSO through your identity provider, and use a project with role-based access control (RBAC) to scope exactly what each team can deploy and where</li><li><strong>Split your repositories</strong>: Keep application source code and deployments in separate repos, because if they live together, your CI pipeline will commit a new image tag, which will trigger CI again, which in some cases might commit again, making you end up in a loop</li><li><strong>Handle secrets properly</strong>: You can take advantage of SealedSecrets, or better yet, the External Secrets Operator pulling from HashiCorp Vault, AWS Secrets Manager, or OpenBao</li></ul><h3>Key takeaways</h3><p>Argo CD turns Git into the single source of truth for your cluster, enabling drift detection, a full audit trail, and deployments that don’t require handing out cluster credentials.</p><p>Start by learning the fundamentals, then take one of your real applications running in Kubernetes, move its manifests into a repository, and point a single application to it with auto-sync off. If you want to compare Argo CD with the other big GitOps option, we covered both in <a href="https://lenshq.io/blog/gitops-argocd-flux/">implementing GitOps with Argo CD and Flux</a>.</p><p>Lens Kubernetes IDE will help you manage your Argo CD workflows with ease, giving you the visibility you need to understand their sync and health status at a glance. If you want to see how Lens K8S IDE helps with your Kubernetes clusters and Argo CD, <a href="https://lenshq.io/contact/">book a demo with one of our engineers</a>.</p><h3>FAQ</h3><p><strong>What is Argo CD used for?</strong></p><p>Argo CD is used for continuous delivery of your applications to Kubernetes using GitOps. You simply declare the desired state of your applications in Git, and Argo CD keeps your cluster in sync with it. You get drift detection out of the box, plus an audit trail for every change.</p><p><strong>Is Argo CD free?</strong></p><p>Yes, Argo CD is open source under the Apache 2.0 license, and it is a CNCF graduated project. You can run it in any Kubernetes cluster without any licensing costs, but there are several vendors that also offer managed or enterprise versions as well.</p><p><strong>What is the difference between sync and health in Argo CD?</strong></p><p>Sync checks if Git definitions match your Kubernetes cluster, while health checks if the application manifests are working properly.</p><p><strong>Does Argo CD replace my CI pipeline?</strong></p><p>No, Argo CD handles the delivery side, but your CI pipeline still builds, tests, and pushes your container images.</p><p><strong>How does Lens Kubernetes IDE help with Argo CD?</strong></p><p>Lens Kubernetes IDE automatically detects the Argo CRDs as soon as they are available in the cluster. From there, you get a dashboard that shows you how many applications are synced, healthy, out of sync, progressing, degraded, or missing, along with a “Needs attention” panel that lists problematic applications and the real reason behind each one. You can trigger sync and refresh actions, and even see a timeline of all the events that have happened to your Argo CD applications.</p><p><em>Originally published at </em><a href="https://lenshq.io/blog/argocd-tutorial/"><em>https://lenshq.io</em></a><em> on September 18, 2026.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=be83fd8d0d00" width="1" height="1" alt=""><hr><p><a href="https://medium.com/k8slens/argo-cd-tutorial-from-installation-to-app-of-apps-and-applicationsets-be83fd8d0d00">Argo CD Tutorial: From Installation to App of Apps and ApplicationSets</a> was originally published in <a href="https://medium.com/k8slens">k8slens</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How to run Hermes Agent Securely in Enterprise Environments]]></title>
            <link>https://medium.com/k8slens/how-to-run-hermes-agent-securely-in-enterprise-environments-6b63407af9d5?source=rss----1074b70245e3---4</link>
            <guid isPermaLink="false">https://medium.com/p/6b63407af9d5</guid>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[hermes-agent]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[lens-agents]]></category>
            <category><![CDATA[ai-security]]></category>
            <dc:creator><![CDATA[Flavius Dinu]]></dc:creator>
            <pubDate>Fri, 14 Aug 2026 10:42:46 GMT</pubDate>
            <atom:updated>2026-08-14T10:42:46.250Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*X8OGJo-QKybpAYtzSrjegw.png" /></figure><ul><li>Hermes Agent from Nous Research is one of the most popular self-improving AI agents.</li><li>Autonomous agents like Hermes typically have your credentials in their environment and unrestricted outbound network access.</li><li>Securing an AI agent comes down to five areas: identity, networking, credential isolation, runtime containment, and audit.</li><li>In this post, you’ll learn how to secure your Hermes Agent from scratch, and how Lens Agents gives you that governance out of the box.</li></ul><p><a href="https://hermes-agent.nousresearch.com/">Hermes Agent from Nous Research</a> is an autonomous AI agent that keeps state, works goals over time, talks to you through Slack, Telegram, WhatsApp, or Discord, and runs continuously.</p><p>That makes it really powerful, but an agent that never sleeps and can use several different tools is an agent that needs real boundaries.</p><p>Prefer to watch instead:</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2FKWTO8tAbllQ%3Ffeature%3Doembed&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DKWTO8tAbllQ&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2FKWTO8tAbllQ%2Fhqdefault.jpg&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/c0b1e8b5ef2b423abd7e50730e27a5bc/href">https://medium.com/media/c0b1e8b5ef2b423abd7e50730e27a5bc/href</a></iframe><h3>Why Autonomous AI Agents Raise Security Concerns</h3><p>Coding assistants and chatbots mostly act when you ask them to do something. Autonomous agents are a different category, because they monitor, decide, and act on their own schedules. Hermes Agent can watch a Slack channel, pick up a task, run tools, and report back hours later with no human in the loop.</p><p>None of that is a flaw, and it applies to any autonomous agent you run directly on a host.</p><p>The default deployment pattern for an AI agent looks like this:</p><ul><li><strong>Credentials live in the agent’s environment</strong>: API keys, tokens, kubeconfig, and cloud credentials typically sit in config files or environment variables, where the agent (and anything that compromises it) can read them.</li><li><strong>The network is open</strong>: The agent can call any endpoint on the internet. If it gets prompt-injected into exfiltrating data, nothing stops the outbound request from reaching the attacker who wants that data.</li><li><strong>The host gets inherited</strong>: The agent can read the host’s filesystem, install packages on it, and reach the internal network.</li><li><strong>There’s no audit trail</strong>: You won’t know what the agent has done, and you won’t have any history of when something changed or why.</li><li><strong>It’s always on</strong>: Always-on is a powerful feature for an autonomous agent, but without guardrails it also means a window of exposure that never closes.</li></ul><p>All of that is manageable for a personal project. Point it at real production data and the risks become real, which is why most enterprises either ban autonomous agents or end up running them ungoverned as shadow IT. Neither is a good outcome, so let’s fix the deployment model.</p><h3>What Does Secure Mean for an AI Agent?</h3><p>To be secure, an AI agent needs:</p><ul><li><strong>Its own identity</strong>: The agent should act as itself, not be mistaken for the user who owns it. Every action should be attributable to the agent, with its own permissions.</li><li><strong>Least privilege and default-deny</strong>: The agent should access <strong>only</strong> the systems it needs, and nothing else.</li><li><strong>Credential scoping</strong>: Secrets held by the agent should be narrow, short-lived, and revocable. Ideally, they shouldn’t be held by the agent at all.</li><li><strong>Runtime containment</strong>: The agent process should be isolated from the host and always run as an unprivileged user, so a compromised agent doesn’t become a compromised host.</li><li><strong>Audit</strong>: You should know exactly what the agent is doing — what commands it runs, which tools it uses, which API calls and network requests it makes, and which model it used.</li></ul><p>Now that we know what we need, let’s look at how to get there with Hermes.</p><h3>How to Harden a Self-Hosted Hermes Agent</h3><p>This is a step-by-step guide to the decisions you need to make to harden Hermes Agent in your environment.</p><h3>Step 1: Contain the runtime</h3><p>First, make sure your agent doesn’t run directly on your host, and doesn’t run as root. Most people run Hermes in a container as an unprivileged user, with all Linux capabilities dropped and privilege escalation disabled.</p><p>That’s a good starting point, but you can do better. If you want stronger isolation than a shared kernel, run this setup in a microVM. A microVM strips a VM down to its essentials, boots in seconds, and gives you a hardware-level boundary, which makes it a better fit than containers for this type of workflow.</p><p>Learn more about <a href="https://lenshq.io/blog/vms-vs-containers-vs-microvms/">why microVMs win for agentic AI workflows</a>.</p><h3>Step 2: Control the egress</h3><p>The worst outcome of prompt injection is exfiltration. When you control egress, the agent can only reach an explicit allowlist of destinations, and everything else is refused.</p><p>You can point Hermes at a proxy through an environment variable, then block direct egress from the agent’s network with firewall rules. When prompt injection happens, it fails at the network layer and the attempt lands in your proxy logs.</p><h3>Step 3: Give your Hermes Agent its own identity</h3><p>Think about Kubernetes for a second. If your agent has access to your kubeconfig, the agent effectively <em>is</em> you (with cluster-admin privileges on a bad day), and every action it takes is attributed to your name in the audit log.</p><p>Create a dedicated ServiceAccount for the agent instead, and scope role-based access control (RBAC) to exactly what the agent needs to do.</p><p>Apply the same principle everywhere else the agent touches: your version control system, your cloud account, and any other system it reaches.</p><h3>Step 4: Keep credentials short-lived</h3><p>Long-lived static credentials are a nightmare in non-agentic workflows. Add AI to the equation and they become a catastrophe. Scoping and short lifetimes shrink the blast radius, but they don’t eliminate it.</p><p>For true credential isolation, the agent must never see a usable secret. That means a boundary between the agent and the credential, which is hard to build yourself — we’ll cover something that helps with that later in the article.</p><h3>Step 5: Build an audit trail</h3><p>You need to answer who did what, and when. Build that from logs, not from the agent’s memory. Use proxy access logs, the Kubernetes API server’s audit logs, and CloudTrail (or the equivalent logging system for your cloud), and ship all of it to a single place.</p><h3>Step 6: Cap the blast radius of always-on</h3><p>Set spending caps on the model provider API key. If you run the agent in a container, set resource limits too. Then configure Hermes’ own autonomy and approval settings conservatively: suggestions first, actions only once you’ve established trust.</p><h3>Is My Hermes Agent Secure After These Six Steps?</h3><p>If you followed every step above, your self-hosted Hermes Agent is dramatically safer than a default deployment. You’ve solved most of the problems a vanilla Hermes deployment has, and it took real work. Two problems remain:</p><ul><li>The agent still holds readable secrets.</li><li>Your guardrails live in five different places, with no single view of what any agent can do.</li></ul><p>That’s where Lens Agents comes in.</p><h3>Running Hermes on Lens Agents</h3><p>Lens Agents is an agentic AI governance platform you install in your own environment with Helm. You can run Hermes fully sandboxed on the platform, and out of the box you get:</p><ul><li><strong>Identity</strong>: Every agent in Lens Agents is a first-class principal with its own token, and all actions are attributed to the agent automatically.</li><li><strong>Default-deny networking</strong>: Kernel-level isolation with a policy-controlled proxy, including per-domain HTTP method and path restrictions.</li><li><strong>Real credential isolation</strong>: Credentials are applied at the platform boundary and never exist in the agent’s environment.</li><li><strong>Audit trail</strong>: Every tool call, shell command, network request, and model invocation lands in one queryable place, exportable to your SIEM.</li><li><strong>Spending limits</strong>: Define limits per organization, per team, and per agent.</li><li><strong>AWS and Kubernetes integrations</strong>: Lens Agents integrates natively with AWS and Kubernetes, so your Hermes Agent can use them with governance in play.</li></ul><p>Lens Agents supports Hermes out of the box, and creating a Hermes agent with all the governance in place is as simple as clicking a button:</p><h3>Key Points</h3><p>Hermes is a very capable autonomous agent, and the instinct to run it against real infrastructure is the right one, that’s exactly where the value is. The biggest mistake you can make is running it with the access model of a shell script: your credentials, your host, open egress, and no audit trail.</p><p>Your organization will never agree to that, so make sure identity, default-deny networking, scoped credentials, containment, and audit are all in place when you work with Hermes.</p><p>You can also run Hermes on Lens Agents and get the whole model as the default, including the credential isolation you can’t reasonably hand-roll.</p><p>If you want to see Hermes running governed against your own clusters and accounts through Lens Agents, <a href="https://lens-agents-contact.lenshq.io/">book a demo with one of our engineers</a>.</p><h3>FAQ</h3><p><strong>What is Hermes Agent?</strong></p><p>Hermes Agent is an autonomous, self-improving AI agent from Nous Research.</p><p><strong>Is it safe to run Hermes Agent in an enterprise environment?</strong></p><p>Running Hermes Agent with a vanilla setup, where you have open egress and all your credentials on the host, isn’t safe. Running it with its own identity, default-deny networking, short-lived credentials, an audit trail, a contained runtime, and spending limits makes it enterprise-ready.</p><p><strong>Can Hermes Agent read or leak my credentials?</strong></p><p>Any secret available in your agent’s environment can be read by the agent process, and by anything that compromises it. Scope your credentials narrowly, or better yet use a credential boundary where the agent never holds a usable secret at all.</p><p><strong>What happens if Hermes Agent gets prompt injected?</strong></p><p>With prompt injection, your agent will try to do something it shouldn’t. Whether the attempt succeeds is decided by the infrastructure beneath it. With proper guardrails in place, even a fooled agent stays a contained one.</p><p><strong>Do I still need governance if my Hermes Agent is read-only?</strong></p><p>Yes, because exfiltration is still possible. Even a read-only agent can be used to steal your data if there are no guardrails in place.</p><p><strong>Does running Hermes Agent on Lens Agents change how I work with it?</strong></p><p>No. You get the same Hermes Agent and the same workflows you already use. The difference is that Hermes runs fully sandboxed with its own identity, credentials are applied at the network boundary instead of living in the agent’s environment, and every action lands in an audit trail, so you always know what happened and when.</p><p><em>Originally published at </em><a href="https://lenshq.io/blog/how-to-run-hermes-agent-securely/"><em>https://lenshq.io</em></a><em> on August 13, 2026.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6b63407af9d5" width="1" height="1" alt=""><hr><p><a href="https://medium.com/k8slens/how-to-run-hermes-agent-securely-in-enterprise-environments-6b63407af9d5">How to run Hermes Agent Securely in Enterprise Environments</a> was originally published in <a href="https://medium.com/k8slens">k8slens</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[VMs vs Containers vs MicroVMs: Which to Choose for Your Workloads]]></title>
            <link>https://medium.com/k8slens/vms-vs-containers-vs-microvms-which-to-choose-for-your-workloads-9040b229c216?source=rss----1074b70245e3---4</link>
            <guid isPermaLink="false">https://medium.com/p/9040b229c216</guid>
            <category><![CDATA[virtual-machine]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[microvm]]></category>
            <category><![CDATA[containers]]></category>
            <category><![CDATA[devops]]></category>
            <dc:creator><![CDATA[Flavius Dinu]]></dc:creator>
            <pubDate>Fri, 31 Jul 2026 13:51:48 GMT</pubDate>
            <atom:updated>2026-07-31T13:51:48.902Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*zeDVRKxZeHuhDRC-.png" /></figure><p>TL;DR:</p><ul><li>Virtual Machines (VMs) are slow to boot and consume the most resources, but provide the strongest isolation through hardware virtualization.</li><li>By sharing the host kernel, containers are extremely fast and portable, but at the same time the isolation boundary is soft.</li><li>MicroVMs (Firecracker, Kata Containers) strip the VM down to its essentials, booting in seconds with a hardware-level boundary.</li><li>For untrusted code and autonomous AI agents, MicroVMs are quickly becoming the required standard, especially under regulations like the EU AI Act.</li></ul><p>Infrastructure has gone through three big shifts in the last two decades. First, we ran applications directly on physical servers. Then Virtual Machines (VMs) let us slice one server into many isolated systems. Then containers made everything faster and lighter. Each step traded something away to gain something else, and the trade has almost always been the same: strong security isolation on one side, speed and agility on the other.</p><p>VMs give you a hardened boundary but they’re heavy. Containers are fast but they share the host kernel. For years, you had to pick one of the two.</p><p>MicroVMs are the technology that finally refuses to pick. They give you container-like startup speed inside a real, hardware-enforced VM boundary.</p><p>In this article, we’ll walk through how all three work, where each one still wins, and why MicroVMs are becoming the default answer for untrusted code and AI agent workloads.</p><p>Check out the video:</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2FbfmBJ-th2-4%3Ffeature%3Doembed&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DbfmBJ-th2-4&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2FbfmBJ-th2-4%2Fhqdefault.jpg&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/72c6e56cf4c6c92fb26e3958c31f1dd6/href">https://medium.com/media/72c6e56cf4c6c92fb26e3958c31f1dd6/href</a></iframe><h3>What is a Virtual Machine?</h3><p>A virtual machine is a complete computer that runs directly in software, having its own guest operating system, its own kernel, and even its own virtual hardware.</p><p>What makes this virtualization possible is the hypervisor, and this comes in two flavors:</p><ul><li><strong>Bare-metal:</strong> This runs directly on the physical hardware (KVM, VMware ESXi, Xen, and others). These are typically used in cloud providers and data centers.</li><li><strong>Hosted:</strong> These run as an application on top of an existing OS (VirtualBox and VMware being classic examples). They are great for personal computers, not for production use cases.</li></ul><p>The hypervisor helps you divide the physical machine’s CPU, memory, storage, and network into isolated slices, so each guest OS believes that it has all the hardware to itself.</p><p>The big strength of a VM is hardware isolation, and a VM can’t see or interact with another VM’s memory because the boundary is enforced by the CPU itself. This still makes VMs the gold standard for multi-tenant environments where you’re running workloads from different customers or even teams that shouldn’t interact with each other, everything on the same hardware.</p><p>The biggest weakness of a VM is its weight, and this happens because every VM boots a full operating system, meaning that boot times are measured in minutes, and the memory footprint is measured in gigabytes, even before your application starts. If you are running, for example, 100 VMs, this means that you are running 100 kernels, and 100 copies of everything an OS needs.</p><h3>What is a Container?</h3><p>Containers have a different approach from virtual machines. They are not virtualizing the hardware as VMs do, they are virtualizing the operating system. This means that every container on a single host shares the same kernel.</p><p>There are two Linux kernel features that keep them separated:</p><ul><li><strong>Namespaces:</strong> They control what a container can actually see (its own process tree, network interfaces, filesystem view, and hostname).</li><li><strong>cgroups:</strong> They control what a container can actually use (CPU, memory, and I/O limits).</li></ul><p>Containers boot in milliseconds and add almost no overhead because there is no guest OS to boot. With a container image you can bundle your application with its dependencies, and then this same image will run exactly the same on your laptop, on your colleague’s laptop, in the cloud, or in CI/CD pipelines. They solve the “it works on my machine” problem.</p><p>Kubernetes (K8s) transformed container orchestration. With K8s you can schedule, scale, and self-heal your containers, making it easy to run and manage thousands of them.</p><p>Because containers have a shared kernel, an attacker that finds a kernel vulnerability and escapes the container will land on the host. By landing on the host, they will get a path to every other container running on that host.</p><p>This doesn’t make containers insecure. If you trust the code you are running (your own microservices, your own CI/CD pipelines), the shared kernel and its risks are a reasonable tradeoff for the speed you get. The problem with containers comes when you run something that you can’t fully trust.</p><h3>What is a MicroVM?</h3><p>So a VM is a strong but heavy option, while a container is a fast but soft option.</p><p>A MicroVM is the middle option, and it’s a real virtual machine that runs on a stripped-down hypervisor with a minimal guest kernel and almost no emulated devices. There are two implementations that are well known:</p><ul><li><strong>Firecracker:</strong> This is built by AWS to power Lambda and Fargate. It emulates only a handful of devices, and boots a guest in around 125 milliseconds with roughly 5 MB of memory overhead per MicroVM.</li><li><strong>Kata Containers:</strong> This wraps each container (or pod) in its own lightweight VM, so you can keep your K8s workflows while gaining a hardware boundary.</li></ul><p>A virtual machine emulates all the hardware, but almost none of it is needed to run modern Linux workloads. MicroVMs delete all of it, and what’s left boots in seconds (often less), and exposes only a tiny surface to attacks.</p><p>With a MicroVM you get the security profile of a VM, with the density and deployment speed of a container.</p><p>And this matters beyond performance, because regulations like the EU AI Act and the Cyber Resilience Act are pushing hard requirements around how software (especially AI systems) must be contained and controlled. MicroVMs make it practical to give every workload an immutable and isolated environment with a clean and auditable boundary.</p><p>MicroVM adoption is rising right now, and this happens because of autonomous AI agents. AI agents are not normal applications, because they generate and execute actions at runtime, meaning that you can’t fully review their behavior in advance. This makes them non-deterministic.</p><p>If an agent runs in a plain container and something goes wrong, and many things can (prompt injection, a compromised tool, or even a hallucinated command), the shared kernel is a thin wall between one misbehaving agent and your entire host.</p><p>Agents need bounded execution where each of their actions is observable, and the blast radius of a mistake is one disposable MicroVM, not a cluster-wide incident. This is exactly why MicroVMs are becoming a baseline requirement for agentic infrastructure.</p><h3>When to choose Virtual Machines, Containers, or MicroVMs?</h3><p>Each of these three have their own strengths and weaknesses, and they all have a path where they are the clear winner:</p><ul><li><strong>VMs</strong> should be chosen for complex and stateful applications that need high-performance hardware.</li><li><strong>Containers</strong> are the right choice where iteration speed is a primary driver (your own microservices, CI/CD pipelines, and standard cloud native environments).</li><li><strong>MicroVMs</strong> should be chosen for Function as a Service platforms, untrusted code execution, and AI agent sandboxing.</li></ul><h3>How does Lens Agents use MicroVM Isolation?</h3><p>Lens Agents is a governed platform for running AI agents against real enterprise systems. In the platform, every agent runs in its own isolated execution environment, so a misbehaving or compromised agent is contained by design.</p><p>The agents running in the platform don’t have access to the real credentials they need to use, as they are injected at the network boundary. They always hold just placeholder credentials, so even if an agent is compromised, the attacker will get away with nothing.</p><p>At the same time, every action an agent takes is logged and fully auditable, which maps directly to the traceability requirements in the EU AI Act.</p><p>See Lens Agents in action:</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2FggqTK-uIAeI%3Ffeature%3Doembed&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DggqTK-uIAeI&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2FggqTK-uIAeI%2Fhqdefault.jpg&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/ee296a161de935d5db0230f9d2958d19/href">https://medium.com/media/ee296a161de935d5db0230f9d2958d19/href</a></iframe><h3>Key points</h3><p>Infrastructure isn’t a choice between just Virtual Machines and Containers anymore. Modern platforms will run three: VMs for heavy workloads, containers for trusted cloud-native services, and MicroVMs for everything that needs container-like speed and requires a more powerful boundary.</p><p>If you want to see how governed and isolated AI agents work in practice, <a href="https://lenshq.io/products/lens-agents">book a demo with the Lens team</a>.</p><h3>FAQ</h3><p><strong>Are MicroVMs replacing containers?</strong></p><p>No, MicroVMs and containers solve different problems. For trusted cloud native microservices, containers remain the better choice because nothing beats their density and startup speed. MicroVMs take over in cases where code cannot be fully trusted: multi-tenant platforms, serverless functions, and AI agent execution.</p><p><strong>Can I run MicroVMs on my existing Kubernetes cluster?</strong></p><p>Yes, and the most common path is Kata Containers. The main requirement is that your Kubernetes nodes support hardware virtualization (or nested virtualization if your nodes are VMs themselves).</p><p><strong>Why can’t I just sandbox AI agents with regular container security tools?</strong></p><p>AI agents are a special case because they are generating actions at runtime. This means that you can’t review their behavior in advance the way you review your own code. By having a hardware-enforced boundary, even if an agent is compromised, the damage stops at the edge of one disposable MicroVM.</p><p><em>Originally published at </em><a href="https://lenshq.io/blog/vms-vs-containers-vs-microvms"><em>https://lenshq.io</em></a><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9040b229c216" width="1" height="1" alt=""><hr><p><a href="https://medium.com/k8slens/vms-vs-containers-vs-microvms-which-to-choose-for-your-workloads-9040b229c216">VMs vs Containers vs MicroVMs: Which to Choose for Your Workloads</a> was originally published in <a href="https://medium.com/k8slens">k8slens</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[MCP Security: Tool Poisoning, Line Jumping & Rug Pulls Explained]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://medium.com/k8slens/mcp-security-tool-poisoning-line-jumping-rug-pulls-explained-420eb8eaa029?source=rss----1074b70245e3---4"><img src="https://cdn-images-1.medium.com/max/1920/0*832N8ZpZ2wi5P_PO.png" width="1920"></a></p><p class="medium-feed-snippet">MCP servers feed instructions straight into your model&#x2019;s context. Learn how tool poisoning, line jumping, and rug pull attacks work.</p><p class="medium-feed-link"><a href="https://medium.com/k8slens/mcp-security-tool-poisoning-line-jumping-rug-pulls-explained-420eb8eaa029?source=rss----1074b70245e3---4">Continue reading on k8slens »</a></p></div>]]></description>
            <link>https://medium.com/k8slens/mcp-security-tool-poisoning-line-jumping-rug-pulls-explained-420eb8eaa029?source=rss----1074b70245e3---4</link>
            <guid isPermaLink="false">https://medium.com/p/420eb8eaa029</guid>
            <category><![CDATA[mcps]]></category>
            <category><![CDATA[model-poisoning]]></category>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[mcp-security]]></category>
            <category><![CDATA[mcp-server]]></category>
            <dc:creator><![CDATA[Flavius Dinu]]></dc:creator>
            <pubDate>Fri, 24 Jul 2026 08:32:12 GMT</pubDate>
            <atom:updated>2026-07-24T08:32:12.251Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[AI Agents Are Non-Human Identities: A 2026 Security Guide]]></title>
            <link>https://medium.com/k8slens/ai-agents-are-non-human-identities-a-2026-security-guide-5af34abca21a?source=rss----1074b70245e3---4</link>
            <guid isPermaLink="false">https://medium.com/p/5af34abca21a</guid>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[identity-management]]></category>
            <category><![CDATA[ai-agent-governance]]></category>
            <dc:creator><![CDATA[Flavius Dinu]]></dc:creator>
            <pubDate>Fri, 19 Jun 2026 08:20:19 GMT</pubDate>
            <atom:updated>2026-06-19T08:20:19.592Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*yven6ag5N2JhxR7D.png" /></figure><p>TL;DR:</p><ul><li>Non-Human Identities (NHI) (service accounts, AI agents, machine credentials) now outnumber human users by a wide margin, and <a href="https://kpmg.com/hr/en/insights/technology/2026/01/invisible-access-visible-risk.html">KPMG’s 2026 report</a> makes governing them a top CISO priority</li><li>Agents are the new insider threat: an overprivileged agent can exfiltrate data at machine speed without ever compromising a human credential</li><li>Agents need secrets and credentials to do anything useful. At the same time, credentials accessible at runtime are a breach waiting to happen</li><li>Treating an agent like the NHI it is means binding its identity, injecting (but never embedding) its credentials, ensuring it can access the minimum things it needs to access with minimum permissions in order to execute its task, and auditing every action (including the ones that are failed and denied)</li><li>Lens Agents solves these issues by ensuring that your agents can access only the domains you allow them to access, credentials injection happens at the relay so secrets never live in the agent runtime, every agent has its own identity, every action is audited, there are different spending limits per agent/team/organization, and more.</li></ul><p>What to see Lens Agents in Action?</p><p>Check out our latest 20-minute webinar in which you’ll see the problems with agentic workflows, what Lens Agents is, and how it can help, and a demo of the platform:</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2F_9PtwrrxIBc%3Ffeature%3Doembed&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3D_9PtwrrxIBc&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2F_9PtwrrxIBc%2Fhqdefault.jpg&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/ed55b34f08ba625970e6b76f8e5c8c95/href">https://medium.com/media/ed55b34f08ba625970e6b76f8e5c8c95/href</a></iframe><h3>What Non-Human Identity Actually Means?</h3><p>A Non-Human Identity, or NHI, is an identity that isn’t a person. There are many NHIs, and they have existed for a long time:</p><ul><li><strong>API keys and tokens</strong>: credentials that grant programmatic access to an application or system</li><li><strong>OAuth tokens</strong>: Access grants that let one service act on behalf of another</li><li><strong>Machine certificates</strong>: Cryptographic identities for workloads and devices</li><li><strong>Service accounts</strong>: Identities applications use to communicate with other applications</li></ul><p>Most of these NHI were predictable in the past. For example, a deployment pipeline that touches a registry or a logging service that retrieves logs from a logging endpoint. AI agents, however, are the newest members of this category, and they are the ones that are actually breaking the existing model.</p><p>An AI agent is different from a traditional NHI because it reasons, chains actions together, decides at runtime which tools to call, and most of the time, right now, it carries elevated privileges because no one is implementing least privilege properly. This autonomy, plus its broad access, is exactly what makes an AI agent valuable, but at the same time, it is exactly what makes it very dangerous.</p><h3>Why Non-Human Identity is the New Security Perimeter?</h3><p>Right now, it’s clear that you are no longer primarily defending human logins. You are in the non-human identity perimeter, and the agents inside it operate with administrative-level reach.</p><p>Enterprises spend decades hardening the human identity perimeter, but that investment addresses only half of the platform. This is also shown in this <a href="https://labs.cloudsecurityalliance.org/research/csa-whitepaper-nonhuman-identity-agentic-ai-governance-v1-cs/">whitepaper</a>.</p><p>The number behind this trend is real, even if the exact ratio depends on who you ask. CyberArk’s 80-to-1 NHI-to-HI ratio is the most-cited number. The Cloud Security Alliance reports an average of 45-to-1, which rises in cloud-native environments to 144-to-1, while other vendors put it at over 100-to-1. Even though the ratio varies by source, one thing is clear: NHIs are outscaling human identities by one to two orders of magnitude, and the gap widens whenever a platform team automates another workflow.</p><h3>Why AI Agents Break Traditional Identity Governance?</h3><p>The governance tools the industry built in the last few years were built for humans. You onboard a person, review their access quarterly, and offboard them when they leave. Every one of these steps assumes a relatively small number of people (of course, in big enterprises, there might be hundreds or thousands a month), who change slowly and act at human speed.</p><p>Agentic AI is shifting all of these assumptions:</p><ul><li>You can spin up thousands of agentic identities in the time it takes to onboard a single employee</li><li>An AI agent is able to act in milliseconds, so a quarterly review is meaningless for catching a bad decision</li><li>Agents can accumulate broad access because least privilege can be annoying to implement, and easy to skip</li><li>It’s almost impossible to see what an agent did and why, and this means that you’re not actually in control of the data it can touch.</li></ul><p>An overprivileged agent can be compromised through supply chain issues, prompt injection, or a poisoned tool, to name just a few. An attacker uses their existing, legitimate access to exfiltrate data at machine speed. They don’t even need to phish any human credentials, since the breach can occur directly on an NHI that no one is watching.</p><h3>Why AI Agent Credentials Should Never Live in the Agent?</h3><p>An agent is useless without credentials because to do real work, it needs to authenticate with your cloud provider, Kubernetes clusters, databases, or internal APIs.</p><p>So, where do most enterprises store these secrets? Well, the lazy answer is to put them in the agent runtime (environment variables, a config file, a token pasted in the orchestration layer). The moment you actually do that, the agent becomes a walking secret store that can be easily exploited.</p><p>Every one of these locations is a place where a secret can actually leak:</p><ul><li>A compromised dependency reads the config file</li><li>The model itself ends up reflecting credentials back in an output</li><li>Prompt injection convinces the agent to print its own environment</li><li>A debugging log captures the token in plaintext</li></ul><p>The entire industry is currently shifting away from putting static secrets in the agent’s runtime. Injecting credentials at call time, at the layer the agent can’t see, is the only way to ensure your credentials aren’t leaked.</p><h3>How to Secure AI Agents as Non-Human Identities?</h3><p>An agent is an NHI, and it should be treated as such. You should apply the same disciplines you’d apply to any high-profile machine identity that’s adapted for autonomy:</p><ul><li><strong>Inject, don’t embed</strong>: Credentials should always be supplied to the agent’s requests at a controlled layer, and never stored in the agent’s runtime or memory</li><li><strong>Scope by least privileged: </strong>Even though this process might seem complicated in the beginning, it’s well worth the trouble. Define what the agent is allowed to reach (which domains, which methods) and deny everything else by default</li><li><strong>Bind the identity</strong>: Your agents’ identities should map clearly to a real federated identity via your existing SSO, so every action can be traced back to a known principal. Your agents shouldn’t be anonymous.</li><li><strong>Audit everything</strong>: You should have a full trail of what the agents did, tried to do, and where they’ve done it</li><li><strong>Cap the blast radius</strong>: Implementing spending limits and rate control means that a compromised agent can’t run up unbounded cost or damage</li><li><strong>Define autonomy explicitly</strong>: Not all your agents should be allowed to act on their own. Match the level of human oversight with the level of risk</li></ul><h3>How Lens Agents Secures Non-Human Identities</h3><p>It’s easy to say “treat agents like NHI”, but building the layer that actually enforces it is the hard part. This is where Lens Agents comes in.</p><p>Lens Agents is a governed platform for running AI agents against real enterprise systems, and its design maps directly to all the problems and solutions we’ve described above:</p><ul><li><strong>Credential injection happens at the relay</strong>: Secrets are injected into the agent’s requests at the relay, not in the agent runtime. In this way, the agent never holds the credentials, so there is nothing available to be compromised by prompt injection or by a leaked log</li><li><strong>Kernel-level sandbox enforcement</strong>: Managed agents in the platform run inside a sandbox (light VMs that run a user-provided image with its own policy data)</li><li><strong>Full audit trails</strong>: Every request is logged, including ones that are blocked. You don’t just see what happened; you also see what the agents attempted and where the guardrails held.</li><li><strong>Identity bounding</strong>: Every single agent is bound to a real identity. There are no anonymous agents and no orphaned tokens. Every action an agent takes is attributable to a known principal.</li><li><strong>Policy Engine</strong>: Domain-level and HTTP method/path controls that define what each agent can reach. The policy engine also defines what kind of credentials they will get from the relay, and what integrations they can use</li><li><strong>Spending limits</strong>: There are spending limits available per organization, per token, per user, and per sandbox. A misbehaving agent can’t generate unbounded cost.</li><li><strong>Integrations: </strong>Built-in Integrations with Kubernetes and AWS, others to come</li><li><strong>Framework-agnostic governance:</strong> The controls reside at the platform layer, regardless of the agent framework you use. You can govern agents consistently without mattering how they were built</li></ul><h3>Key Points</h3><p>AI Agents are non-human identities with autonomy and reach, and the governance built for human identities doesn’t work at their scale or their speed.</p><p>The fix is to treat the agents like the NHIs they are with bound identity, injected credentials, scoped permissions, and a full audit trail. Lens Agents gives you exactly that: identity bounding, credential injection happening at the relay, policy engine, spending limits, full audit trail, sandbox environments, and more.</p><p>If you want to see how Lens Agents helps you govern your agentic workflow on a real enterprise system, <a href="https://lens-agents-contact.lenshq.io/">book a demo with one of our engineers</a>.</p><h3>FAQ</h3><h3>What is a non-human identity (NHI)?</h3><p>A non-human identity is any identity that isn’t a person. It can be a service account, an API key, an OAuth token, or even an AI agent. These NHI authenticate to systems and act on their own, and in most enterprises, they outnumber human users by a wide margin.</p><h3>Why are AI agents a security risk?</h3><p>If an agent is compromised through prompt injection, bad dependencies, poisoned tools or others, an attacker can use its legitimate access to exfiltrate data at machine speed. An overprivileged agent is a new kind of insider threat.</p><h3>How do you secure AI agent credentials?</h3><p>Keep credentials out of the agent. Don’t store them at runtime, inject them through a controlled layer the agent never sees, and scope every identity to least privilege. Lens Agents does that with credential injection at the relay, so secrets never live in the agent runtime.</p><p><em>Originally published at </em><a href="https://lenshq.io/blog/ai-agents-non-human-identities"><em>https://lenshq.io</em></a><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5af34abca21a" width="1" height="1" alt=""><hr><p><a href="https://medium.com/k8slens/ai-agents-are-non-human-identities-a-2026-security-guide-5af34abca21a">AI Agents Are Non-Human Identities: A 2026 Security Guide</a> was originally published in <a href="https://medium.com/k8slens">k8slens</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Math Behind Why Multi-Step AI Agents Fail in Production]]></title>
            <link>https://medium.com/k8slens/the-math-behind-why-multi-step-ai-agents-fail-in-production-c6d60ea6ca31?source=rss----1074b70245e3---4</link>
            <guid isPermaLink="false">https://medium.com/p/c6d60ea6ca31</guid>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[ai-workflow]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[automation]]></category>
            <dc:creator><![CDATA[Flavius Dinu]]></dc:creator>
            <pubDate>Wed, 03 Jun 2026 07:15:59 GMT</pubDate>
            <atom:updated>2026-06-03T07:15:59.315Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*U_93vG31KZMBfCO3.png" /></figure><ul><li>Agent reliability compounds: a 95% per step accuracy, gives only ~60% success over 10 steps, and 36% over 20 steps</li><li>Demos usually hide this because they only show 2 or 3 steps. Production environments are usually 5+ steps over messy inputs and edge cases</li><li>The fix is shorter chains, verification between steps, human-in-the-loop for risky action, and guardrails to reduce the blast radius</li><li>Lens Agents reduces the blast radius significantly by enforcing identity, policy, and audit at the platform layer</li></ul><p>Check the video:</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2FzZG3wXvp9UU%3Ffeature%3Doembed&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DzZG3wXvp9UU&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2FzZG3wXvp9UU%2Fhqdefault.jpg&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/67f34b8683406eed6f61ab13ec3c7ab9/href">https://medium.com/media/67f34b8683406eed6f61ab13ec3c7ab9/href</a></iframe><h3>The simple math for reliability</h3><p><a href="https://en.wikipedia.org/wiki/Lusser%27s_law">Lusser’s law</a> in reliability engineering is pretty straightforward. The reliability of a series of components is equal to the product of their individual reliabilities. For example, if each step of an agent’s workflow is independent and succeeds with a probability p, the probability that an n-step task succeeds end-to-end is p^n.</p><p>If we have a step that succeeds with probability 80% and we run a 3-step workflow, the probability of success is 0.8³, or 0.5.</p><p>Let’s explore some more optimistic scenarios:</p><ul><li>99% accuracy per step: 5 steps (~95%), 10 steps (~90%), 20 steps (~81%), 50 steps (~60%)</li><li>95% accuracy per step: 5 steps (~77%), 10 steps (~59%), 20 steps (~35%), 50 steps (~7%)</li></ul><p>A 95% accuracy per-step rate is a very good scenario in practice, but when you look at a workflow with 10 steps, your agentic workflow will fail half the time, and at 50 steps, it’s a coin flip: it succeeds only if the coin stays on the edge.</p><p><strong>Note</strong>: In reality, steps aren’t independent, so the numbers are actually worse than this. An incorrect output at step 2 will be fed to step 3, which will break absolutely everything else. Compounding is actually worse in reality than the raw multiplication suggests.</p><h3>Why do demos lie?</h3><p>Demos are optimized for the happy path in which you have clean data, short chains, no rate limits, no ambiguous inputs, and the list goes on. You have three steps, everything works perfectly, leadership is happy, and you start implementing a similar production workflow.</p><p>But production is a different kind of beast. If you need, for example, to build a workflow that researches a particular incident and drafts a root cause analysis, your agent will actually go through multiple steps:</p><ol><li>Parsing the alert payload</li><li>Query Prometheus for metrics around when the incident happened</li><li>Pull pod logs from the affected namespaces</li><li>Understand how were does pods are created (by a deployment, statefulset, daemonset, standalone, etc)</li><li>Correlate with recent deployments</li><li>Check AlertManager for related firing alerts</li><li>Check what solutions were applied in order to fix it (pull recent GitHub commits)</li><li>Draft the RCA</li><li>Post it to Slack/MS Team/Confluence</li><li>Create a Jira/Azure DevOps/etc ticket</li></ol><p>You will have at least 10 tool calls, and every one of them is a place where your agent can pick the wrong tool, pass wrong parameters, hallucinate a namespace that doesn’t exist, or misread a metric. Even at a very optimistic 95% per step accuracy, this workflow fails about 40% of the time.</p><p>These failures can also be dangerous. The agent completes the workflow successfully and produces a plausible-looking RCA, but nothing is actually correct. Your engineering teams will need to debug the debugger.</p><p>A hard failure is easy because you can retry the workflow, and you know that something went wrong. A soft failure shows you that everything is okay, but in reality, the output is wrong. In addition to that, you might also face context drift, where your agents start subtly reinterpreting the goal based on whatever’s most recent in its context window.</p><h3>So what can you actually do?</h3><p>The models are good enough to do these tasks; it’s not about waiting for a newer and more powerful model. There are four essential things you should implement:</p><ul><li><strong>Shorten the multi-step workflow</strong>: Every step you remove from your workflow is a multiplicative win. Combine steps where possible and use deterministic code for parts that don’t need reasoning</li><li><strong>Verify between steps</strong>: Don’t blindly feed the output of a crucial step to its successor. Check intermediate result against validation rules</li><li><strong>Use human-in-the-loop</strong>: For risky actions, let your agents propose, but a human should approve what they propose.</li><li><strong>Scope the blast radius at the platform level</strong>: Even if the agent is wrong, the damage should be bounded by your governance layer in the platform: Identity, RBAC, Policies</li></ul><p>You can’t make your agents 100% reliable. What you can do is limit the blast radius when they are wrong.</p><h3>Reducing the blast radius with Lens Agents</h3><p>An AI agent that operates in your cloud account or in your Kubernetes clusters makes the compounding error problem even bigger, and you need something to contain it.</p><p>This is where Lens Agents come in. Lens Agents is a governed platform for running AI agents on enterprise systems. You can’t make your agent perfect, but you can make it contained, as Lens Agents offers:</p><ul><li><strong>Identity-bound execution</strong>: Every agent has its own identity, and when something goes wrong at the n-step of your workflow, the audit trail tells you exactly who the agent was, and what it has done</li><li><strong>Policy engine</strong>: Every agent runs under a declarative policy, and you can restrict what domains they can access and what they can actually do</li><li><strong>Credential bindings</strong>: The agent never sees raw credentials, as they are injected by the Lens Agent relay only when a request hits an allowed domain</li><li><strong>Built-in cost control</strong>: You can build spending limits by organization, team, or agent</li><li><strong>MCP native</strong>: Connect natively to AWS, Kubernetes, and any MCP-compatible tool</li><li><strong>Built-in audit trail</strong>: Every tool call and every decision path is captured</li></ul><h3>Conclusion</h3><p>The compounding error problem is real, and at a 95% per-step accuracy, your Agentic workflow will fail most 20-step tasks, and there is no amount of prompt engineering that can fix that.</p><p>Teams that are doing agentic workflow successfully treat reliability as a systems problem by leveraging shorter chains, verification between steps, and hard guardrails at the platform level</p><p>If you want to run AI agents in your production environment without the blast radius keeping you up at night, sign up for Lens Agents early access <a href="https://www.lenshq.io/products/lens-agents">here</a>.</p><p><em>Originally published at </em><a href="https://lenshq.io/blog/ai-agent-compounding-errors-math"><em>https://lenshq.io</em></a><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c6d60ea6ca31" width="1" height="1" alt=""><hr><p><a href="https://medium.com/k8slens/the-math-behind-why-multi-step-ai-agents-fail-in-production-c6d60ea6ca31">The Math Behind Why Multi-Step AI Agents Fail in Production</a> was originally published in <a href="https://medium.com/k8slens">k8slens</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Why AI Agents Fail in Production (and How to Fix It)]]></title>
            <link>https://medium.com/k8slens/why-ai-agents-fail-in-production-and-how-to-fix-it-105677c365bb?source=rss----1074b70245e3---4</link>
            <guid isPermaLink="false">https://medium.com/p/105677c365bb</guid>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[kubernetes]]></category>
            <category><![CDATA[devops]]></category>
            <dc:creator><![CDATA[Flavius Dinu]]></dc:creator>
            <pubDate>Wed, 13 May 2026 05:45:36 GMT</pubDate>
            <atom:updated>2026-05-13T05:45:36.774Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*R2kAXBHnzYc5VH1y.png" /></figure><p>TL;DR:</p><ul><li>Most AI agents fail in production because of multiple reasons:<br>- No governance implemented<br>- Poor context management<br>- Fragile tool connectors<br>- Compounding errors across multi-step workflows</li><li>If an agent, for example, has a 90% per step accuracy, this seems pretty high, right? Indeed, this looks good if you do a single step. But if you compound it across 5 steps, and across 10 steps, the math is not working in your favor any more: you get 59% accuracy for 5 steps, and 35% accuracy for 10 steps.</li><li>Tool calls fail at meaningful rates in production environments, even in well-engineered systems.</li><li>Lens Agents is the governed platform that can help you run AI agents on enterprise systems: any agent, any model, any environment in a single governance plane</li></ul><p>Watch the video:</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2FHWhySGGHqQ0%3Ffeature%3Doembed&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DHWhySGGHqQ0&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2FHWhySGGHqQ0%2Fhqdefault.jpg&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/a0f002a0c0250844359e9ac8b4e9cba2/href">https://medium.com/media/a0f002a0c0250844359e9ac8b4e9cba2/href</a></iframe><p>Agentic AI is increasingly present in production environments. Teams, regardless of their organization size, are wiring up agents for Kubernetes clusters, databases, infrastructure as code (IaC), ticketing systems, CI/CD pipelines, and more.</p><p>The models are good enough and can considerably speed up development time. The MCP ecosystem (even though some claim it is dead) has exploded. There are 97 million monthly SDK downloads.</p><p>Yet, in production environments, the numbers are not looking good: only 12% of enterprise agent initiatives reach production at scale, and Gartner predicts that 40% of agentic AI projects will be scrapped by 2027.</p><p>In this article, we will explore why AI agents fail in production environments, and see what you can do to actually change that.</p><h3>Why is Production Different from Your Dev Environment in Agentic AI?</h3><p>Every failed Agentic AI production project has a somewhat similar story. A small team from your organization starts working on an agent, runs it against test data, and everything seems to be looking great. Leadership teams are getting excited about this, especially because one of the KPIs nowadays is increasing AI consumption.</p><p>This demo gets promoted to the production environment, and things here become messy. The issue isn’t the model you are using, as OpenAI, Anthropic, Google, and others have pretty powerful models. The issues in production environments are:</p><ul><li><strong>More data (and this data can be messy)</strong>: You have typos, missing fields, ambiguous references, and edge cases that nobody anticipated</li><li><strong>APIs are unreliable</strong>: You face rate limits, schema changes, and sometimes undocumented behaviors under load</li><li><strong>Context accumulates</strong>: Multi-turn conversations and multi-step workflows that push past the context window of every model</li><li><strong>Things compound</strong>: One small error in one step of your workflow can cascade across the workflow</li></ul><h3>Most Common Failure Patterns</h3><p>Let’s explore the most common failure patterns in Agentic AI that account for the most production breakdowns.</p><h4>1. Context Failures</h4><p>Most failures aren’t related to the model. If you give the model wrong information, too much information, or information that drifts over time, your model will make decisions based on noise.</p><p>There is a phenomenon called “ <a href="https://arxiv.org/abs/2307.03172">lost in the middle</a> “, which refers to a relationship between increasing the context length and decreasing the accuracy. Performance degradation is real. Even though a model’s spec sheet says it can use 200k tokens effectively, in reality it will use only around 50k tokens.</p><p>Teams typically treat context windows as infinite resources, dumping entire documentation libraries into every request, loading hundreds of past conversations, making the model lose focus on what actually matters.</p><p>Another common mistake is confusing RAG with agent memory:</p><ul><li>RAG fetches relevant documents and facts from an external knowledge base</li><li>Agent memory tracks what happened across turns, sessions, and workflows</li></ul><p>Using the wrong one for the wrong job can create over-engineered agents.</p><p>Here are a couple of things you can do to fix these issues:</p><ul><li><strong>Be ruthless about context</strong>: Load only what the agent needs for the current setup</li><li><strong>Isolate sessions</strong>: If you context bleed across users or jobs, you are actually preparing everything an attacker needs for a data breach</li><li><strong>Validate retrieved content before injecting it</strong>: Stale docs or contradictory sources should be filtered at retrieval time, not left for the model to sort out</li></ul><h4>2. Fragile Tool Connectors</h4><p>Tool calling fails at meaningful rates in production environments. Enterprise APIs were not designed to be called by AI agents; they have rate limits, data format inconsistencies, and undocumented behaviors that only surface under production load.</p><p>Teams estimate integration work based on API documentation, which usually describes ideal behavior. Production integration is different. You need to handle the gap between documented and actual behavior.</p><p>Schema errors are obvious failures, but credential failures are a different story. Expired credentials don’t look like agent problems; they are silent 401s or 403s that the agent doesn’t know how to handle. They will retry; the retry will fail; the agent will pick a different tool; that different tool will fail for the same reason, and so on. Until someone notices that, the agent has burned through tokens, hit rate limits, and produced an answer that looks confident, but it was built on none of the data it was supposed to use.</p><p>How to solve these issues:</p><ul><li><strong>Every external call needs a failure mode</strong>: Try/catch is good, but it’s not enough. What should an agent do when they hit a 403?</li><li><strong>An agent should never silently fail</strong>: Your agents should clearly communicate when they can’t complete a task and escalate to a human when needed.</li><li><strong>Version your schemas</strong>: Always lock your schemas to specific versions as part of your CI pipeline. Don’t let silent upgrades break production.</li><li><strong>Monitor tool call success rates</strong>: If you don’t know your current failure rates, you can’t improve them.</li></ul><h3>3. Compounding Errors across Multi-Step Workflows</h3><p>This is one of the most underestimated failures, but in reality, this is just simple math. For example, an agent with a 90% per-step accuracy sounds excellent, and most teams would be happy with that number. Across a multi-step workflow, this means:</p><ul><li>1 step, a 90% accuracy is 90% success.</li><li>5 steps at 90% accuracy per step is: 0.9⁵ = 59% success rate.</li><li>10 steps at 90% accuracy per step is: 0.9¹⁰ = 35% success rate.</li><li>20 steps at 90% accuracy per step is: 0.9²⁰ = 12% success rate.</li></ul><p>And 90% is really optimistic. The <a href="https://arxiv.org/abs/2601.14242">APEX-Agents 2026 benchmark</a> shows that even the best-performing models completed only 24% of real-world tasks on the first attempt.</p><p>How to fix compounding errors:</p><ul><li><strong>Keep workflows short</strong>: If you can do a task in 3 steps instead of 10, do it in 3.</li><li><strong>Use human-in-the-loop</strong>: Require explicit approvals from a human, especially for destructive operations</li><li><strong>Add validation checkpoints</strong>: After a step finishes, you should ensure that the state matches the expectations before proceeding</li><li><strong>Instrument every step</strong>: It’s important to understand where the agent deviated, not just that it failed</li></ul><h3>The real problem nobody talks about</h3><p>We’ve walked through problems about how agents behave until now. But in reality, these are not the biggest problems in agentic workflow. Agent Governance is one of the most overlooked layers in agentic AI workflows.</p><p>Shadow AI numbers are real:</p><ul><li>80% of employees use unapproved AI tools at work</li><li>92% of organizations lack full visibility into their AI identities</li><li>Shadow AI breaches cost $670K more on average to resolve</li></ul><p>There are four things that typically go wrong, and these have nothing to do with the model you are using:</p><ul><li><strong>There is no agent identity</strong>: The agent uses your developer’s credentials, and there is no way to answer who the agent is, what it was doing, or how to revoke its access without breaking everything else the developer is doing</li><li><strong>There are minimal or no guardrails</strong>: The agent runs freely in your production environments, doing everything it wants, accessing any domains, and not escalating anything to a human</li><li><strong>Credential leaks</strong>: Every secret manager, IAM role, or environment variable the agent needs gets injected directly into its runtime. If that runtime is compromised, the attacker gets everything the agent has</li><li><strong>No audit trail</strong>: When an agent makes unexpected changes, you need to understand what it actually did, on behalf of whom, using which tool, and what result its actions had. Without an audit trail, you are relying solely on chat logs, which are not going to help at scale.</li></ul><p>And these problems are without getting into compliance pressure. The EU AI Act will be fully applicable from August 2, 2026. This requires audit trails for AI agents, agent identity, and human oversight. If you don’t comply, penalties can go up to 7% of global revenue, and let’s face it, most of the enterprises today can’t even answer which agents are running in their environments, let alone what those agents are actually doing.</p><p>This is where Lens Agents come into play.</p><h3>How can Lens Agents help?</h3><p><a href="https://docs.k8slens.dev/lens-agents/">Lens Agents</a> is a governed platform for running AI agents on enterprise systems. You can use any agent, any model, and any environment, and build your custom rules. It was built as one governance plane first, and it offers multiple ways for agents to connect to it.</p><p>Here’s how Lens Agents addresses the issues we’ve explored during this article:</p><ul><li><strong>It offers three agent modes.</strong> All of them governed under the same policies.<br>- Desktop AI tools (e.g., Claude Desktop, Claude Code, Copilot, and others)<br>- External agents built with any MCP-compatible framework (e.g., Claude Agent SDK, CrewAI, AutoGen, and others)<br>- Managed agents created on the platform (these agents are trained using conversation, no need for complicated config files)</li><li><strong>Every agent is a first-class citizen in the platform and has its own identity</strong>: Every action an agent does is attributed to a real identity in the audit trail.</li><li><strong>TLS-intercepting credential injection</strong>: Credentials are injected server-side by the sandbox proxy and are never visible to the agent process. You get an ephemeral per-sandbox Certificate Authority (CA) that terminates the agent’s TLS, injects credentials, and re-encrypts to the real upstream. Even if you have a fully compromised agent, the attacker won’t be able to extract credentials, because these never enter the agent’s process.</li><li><strong>Policy engine</strong>: Every agent runs under a declarative policy. You can control what the agent can access, what domain it can reach, and which credentials it can use.</li><li><strong>Active budgeting</strong>: You can implement budgets per agent, per team, or per organization, and these are checked before every LLM call</li><li><strong>Full audit trail</strong>: Every tool call, proxy decision, LLM request, shell command, and sandbox event are recorded and queryable after the fact</li></ul><p>Lens Agents doesn’t slow down your AI adoption, but it ensures it’s safe without making you choose between speed and control. A user who moves from a Desktop AI tool to a managed agent doesn’t have to leave governance behind, as with Lens Agents, it can take advantage of the same policy engine, budgeting, and full audit trail.</p><h3>Conclusion</h3><p>AI agents work, but just not in the way demos suggest. The teams that are succeeding in production are the ones that are treating agents like any other production system (with governance and observability built-in).</p><p>The uncomfortable truth is that AI agents are already inside your organization, but run with your engineer’s credentials, touching your production systems, and leaving no audit trail. You need a way to govern them without sacrificing speed.</p><p>If you want to see how Lens Agents can enable you to govern your AI agents, sign up for early access <a href="https://www.lenshq.io/products/lens-agents">here</a>.</p><p><em>Originally published at </em><a href="https://www.lenshq.io/blog/why-ai-agents-fail-in-production"><em>https://www.lenshq.io</em></a><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=105677c365bb" width="1" height="1" alt=""><hr><p><a href="https://medium.com/k8slens/why-ai-agents-fail-in-production-and-how-to-fix-it-105677c365bb">Why AI Agents Fail in Production (and How to Fix It)</a> was originally published in <a href="https://medium.com/k8slens">k8slens</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[What Is Platform Engineering? A Practical Guide for Kubernetes Teams]]></title>
            <link>https://medium.com/k8slens/what-is-platform-engineering-a-practical-guide-for-kubernetes-teams-8ed7f00244fb?source=rss----1074b70245e3---4</link>
            <guid isPermaLink="false">https://medium.com/p/8ed7f00244fb</guid>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[education]]></category>
            <category><![CDATA[kubernetes]]></category>
            <category><![CDATA[platform-engineering]]></category>
            <category><![CDATA[cloud-native]]></category>
            <dc:creator><![CDATA[Flavius Dinu]]></dc:creator>
            <pubDate>Mon, 20 Apr 2026 13:04:09 GMT</pubDate>
            <atom:updated>2026-04-20T13:04:09.446Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*ZtY9MK-tCxRSPOEu.png" /></figure><h3>What is Platform Engineering? A Practical Guide for Kubernetes Teams</h3><p><strong>TL;DR</strong>:</p><ul><li>Platform engineering transforms your internal infrastructure into a product, and software developers are your customers</li><li>Internal Developer Platforms (IDPs) help you abstract infrastructure complexity (Kubernetes included) behind self-service portals and golden paths, and also implements automated governance</li><li><a href="https://www.gartner.com/en/infrastructure-and-it-operations-leaders/topics/platform-engineering">Gartner projects that 80% of large enterprises will have dedicated platforms teams by 2026</a></li><li>Backstage, ArgoCD, Crossplane, Kyverno, Lens Kubernetes IDE and others form the backbone of a modern IDP stack on Kubernetes</li></ul><h3>Why does Platform Engineering matter right now?</h3><p>Platform engineering has grown massively during the last few years. What started as a topic that tried to make infrastructure more accessible to developers, has now evolved into a fully automated system that implements all the guardrails necessary to ensure your organization stays compliant.</p><p>KubeCon Europe 2026 had a dedicated Platform Engineering Day, a full BackstageCon, an OpenTofu day, KyvernoCon, ArgoCon, and other events that are related to platform engineering as well. The adoption of platform engineering is real, and this <a href="https://www.cncf.io/wp-content/uploads/2026/01/CNCF_Annual_Survey_Report_final.pdf">CNCF survey shows that over 28% of organizations have a dedicated platform team</a>, while Gartner projects that 80% of large enterprises will have dedicated platform teams by the end of 2026.</p><p>So what is the main driver for adopting platform engineering?</p><p>There are three main reasons:</p><ul><li><strong>DevOps without structure doesn’t scale</strong>: If you are in a small organization, each engineer can own and operate their own CI/CD pipelines and infrastructure. This will work perfectly fine. At scale, however, things change. Having each of your team assemble their own infrastructure tools and practices will create fragmentation and inconsistency.</li><li><strong>AI-generated code is accelerating software delivery, but governance can’t keep up</strong>: The speed vs control paradox is real. Especially now when AI-generated code is in every repository. The need for having a platform that enforces governance rules is more important than ever, as it can take automated decisions for code that violates your standards, without needing human reviews. This reduces fatigue in your engineers.</li><li><strong>Cognitive load is affecting all engineers</strong>: When a software developer is deploying a single microservice he needs to walkthrough Kubernetes manifests, Terraform/OpenTofu code, ArgoCD configurations, Vault policies, Prometheus monitoring rules, Kyverno policies and more. This is simply unsustainable in the long run.</li></ul><p>With platform engineering you are actually shifting this model that doesn’t work at scale anymore. By leveraging platform engineering, you have a dedicated platform team that builds and maintains the shared infrastructure layer as a product, making it easy for others to use it, while making sure that all guardrails are in play.</p><h3>What are the Key Concepts in Platform Engineering?</h3><p>Before jumping in and explaining how a modern Platform looks like, it’s important to understand some of the key concepts you will work with:</p><ul><li><strong>Internal Developer Platform (IDP)</strong>: This is the full stack of your platform, the product that platform teams ship to their customers (Terraform/OpenTofu code, GitOps tools, Kubernetes manifest, Self-service blueprints, and more)</li><li><strong>Internal Developer Portal</strong>: This is typically the frontend interface where developers interact with the platform. Backstage which is now a CNCF project is the most adopted open-source option. This is just a portal, but without Golden Paths, and policy engines into play, this is just a simple catalog with no inventory.</li><li><strong>Golden Paths</strong>: These are blueprints that help you with deploying your infrastructure and ensuring you have all the guardrails you need to achieve security and compliance. By clicking a button, you can deploy a microservice with all the necessary monitoring, security policies, and application configuration. Golden Paths are usually built upon self-service infrastructure.</li><li><strong>Self-service infrastructure: </strong>With self-service infrastructure you let your developers provision infrastructure on their own, without them needing to fill in provisioning tickets, or waiting on your DevOps/Platform Engineering teams.</li></ul><h3>How does a modern IDP Stack look like for Kubernetes</h3><p>There are a couple of layers you need to implement in order to have an IDP Stack for Kubernetes.</p><h3>1. Developer Portal Layer</h3><p>The most dominant choice right now is <a href="https://backstage.io/">Backstage</a>. It comes packed with a software catalog in which you can register different components that can be used by your developers. At the same time, it offers software templates (think of them as golden paths) that can scaffold new services with CI/CD pipelines, Kubernetes manifests, and monitoring all built in.</p><p>Backstage also has a plugin ecosystem that lets you extend the portal with cost dashboards, security scanning results, and others. In addition to that it offers TechDocs for documentation as code that lives alongside your source, and can be seen directly in the portal.</p><p><strong>Note</strong>: Backstage is powerful, but you need engineering resources to build, customize, and maintain your Backstage instance. There are commercial alternatives available like Port, Cortex, and Humanitec that you can check out.</p><h3>2. GitOps and Deployment Layer</h3><p>For Kubernetes, the most popular choices for implementing GitOps are ArgoCD and Flux. These tools ensure that you use Git as your source truth for your Kubernetes cluster state and they equip you with automated and auditable deployments, drift detection and remediation, and also environment promotion workflows.</p><p>If you want to learn more about GitOps with ArgoCD and Flux, check out this <a href="https://lenshq.io/blog/gitops-argocd-flux">article</a>.</p><h3>3. Infrastructure Provisioning Layer</h3><p>Terraform and OpenTofu are the most popular infrastructure provisioning choices. Even if you live in the Kubernetes world 90% of the time, these tools have been battle-tested and there are many other tools in the ecosystem that make them work.</p><p>On the other hand, if you want a Kubernetes native way to provision your infrastructure, Crossplane is a good alternative.</p><p>If you want to learn more about Crossplane, and how it can help you with multi-cloud scenarios, check out this <a href="https://lenshq.io/blog/crossplane-kubernetes-tutorial">article</a>.</p><h3>4. Policy and Security Layer</h3><p>When it comes to policy as code for Kubernetes, <a href="https://lenshq.io/blog/kubernetes-security-kyverno-policy-enforcement-guide">Kyverno</a> offers a native YAML way to enforce your organization rules, while Open Policy Agent (OPA), can help you enforce your rules with a language called rego.</p><p>At the same time, if you need to scan your code for misconfigurations, and vulnerabilities, <a href="https://lenshq.io/blog/secure-kubernetes-with-trivy">Trivy</a> from Aqua Security, can be a great choice for your organization.</p><p>If you want to see what the top 12 Kubernetes Security tools in 2026 are, check out this <a href="https://lenshq.io/blog/best-kubernetes-security-tools">article</a>.</p><h3>5. Observability Layer</h3><p>Prometheus, Grafana, OpenTelemetry, and integrations with Slack/MS Teams, can help you understand, at a glance, if something is wrong in your Kubernetes clusters. Your platform needs to surface the right data in the right context, and a developer shouldn’t have to switch to Grafana or write PromQL to understand why their service is unhealthy.</p><p><a href="https://lenshq.io/blog/prometheus-grafana-kubernetes">Check out how to implement a full monitoring example for Kubernetes using Grafana, Prometheus, Alertmanager, and Slack</a>.</p><h3>6. AI Layer</h3><p>In 2026, AI is present in almost everything that is done in tech. Knowing how to use it properly, will make the difference between platforms that solve the speed-control paradox, and those that don’t.</p><p>Here are some articles that show you how you can implement the AI layer in your platform:</p><h3>Where does Lens Kubernetes IDE fit in the IDP Stack</h3><p>Even if you have Backstage, golden paths, GitOps, Policies, and Security implemented, your developers still need to interact with Kubernetes directly.</p><p>Deployments fail, pods crash, resource limits need tuning, services misbehave, and when that happens, the developer portal is just a starting point for debugging, not the answer.</p><p>This is where Lens Kubernetes IDE comes in as it helps you:</p><ul><li>Understand, at a glance, what is happening with your Kubernetes resources</li><li>Lets you port-forward to services, see pods logs and events, and also make changes to your resources</li><li>Manage your Helm Charts and Custom Resources</li><li>Understand vulnerabilities by using the built-in security center based on Trivy</li><li>Connect to your cloud clusters with ease by using the built-in integrations with AWS, Azure, and soon GCP</li><li>Has a built-in AI assistant called Lens Prism that is context aware and makes it easy to debug your resources</li><li>Connect to your clusters from any AI assistant using Lens Prism</li></ul><p>If you want to learn more about how Lens Kubernetes IDE can help, check out this <a href="https://lenshq.io/blog/lens-kubernetes">article</a>.</p><h3>Conclusion</h3><p>Platform engineering is a shift that is already happening and makes Kubernetes sustainable at scale. The IDP stack is modular, and you should at least have a developer portal, GitOps, infrastructure provisioning, policy, security, observability, and AI built-in.</p><p>Lens Kubernetes IDE completes your platform, and by leveraging Lens Prism you add an AI layer that lets developers ask questions in plain-English and get solutions directly for the problems they are facing.</p><p>If you want to learn more about how Lens Kubernetes IDE fits into your platform engineering workflows, <a href="https://lenshq.io/contact">book a demo with one of our engineers</a>.</p><p><em>Originally published at </em><a href="https://lenshq.io/blog/platform-engineering-kubernetes"><em>https://lenshq.io</em></a><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8ed7f00244fb" width="1" height="1" alt=""><hr><p><a href="https://medium.com/k8slens/what-is-platform-engineering-a-practical-guide-for-kubernetes-teams-8ed7f00244fb">What Is Platform Engineering? A Practical Guide for Kubernetes Teams</a> was originally published in <a href="https://medium.com/k8slens">k8slens</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[18 Best DevOps MCP Servers for 2026 | The Definitive Guide]]></title>
            <link>https://medium.com/k8slens/18-best-devops-mcp-servers-for-2026-the-definitive-guide-bfde04654a35?source=rss----1074b70245e3---4</link>
            <guid isPermaLink="false">https://medium.com/p/bfde04654a35</guid>
            <category><![CDATA[mcp-server]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[model-context-protocol]]></category>
            <dc:creator><![CDATA[Flavius Dinu]]></dc:creator>
            <pubDate>Thu, 02 Apr 2026 07:04:59 GMT</pubDate>
            <atom:updated>2026-04-02T07:04:59.162Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*WJ8ZI_5_26vUl1Qw.png" /></figure><ul><li>Model Context Protocol (MCP) is the open standard introduced by <a href="https://www.anthropic.com/news/model-context-protocol">Anthropic</a> at the end of 2024, which lets AI agents use different tools using natural language</li><li>This article covers 18 relevant MCP servers in the DevOps space across Infrastructure as Code, CI/CD, Containers and Kubernetes, observability, cloud, and incident management</li><li>Most of these servers work with the majority of AI assistants that you use, such as Claude, OpenAI, Gemini, or any compatible ones</li><li>Whenever you are adopting a new MCP server, start with read-only permissions, and scope access carefully before giving write access to production systems</li></ul><p>Watch the video instead:</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2FDEy_QM26brA%3Ffeature%3Doembed&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DDEy_QM26brA&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2FDEy_QM26brA%2Fhqdefault.jpg&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/657afbdf811e5dba3bf6b9094ce134c1/href">https://medium.com/media/657afbdf811e5dba3bf6b9094ce134c1/href</a></iframe><h3>Version Control and CI/CD</h3><h3>1. GitHub MCP Server</h3><p><a href="https://github.com/github/github-mcp-server">GitHub’s MCP Server</a> is the most widely deployed DevOps MCP in the ecosystem. This is largely because GitHub is the most popular version control system. The GitHub MCP Server enables AI agents to browse and search code, create and update issues, open, comment on, and merge pull requests, and even trigger CI/CD workflows through GitHub Actions.</p><p>You can easily ask your agent to review PRs for security issues, check recent commits to understand the specifics of changes to a particular file, or even triage issues by label and assignee.</p><p>It supports a <em>— read-only </em>flag that prevents any mutations.</p><h3>2. GitLab MCP Server</h3><p>Another popular version control and CI/CD MCP server is <a href="https://docs.gitlab.com/user/gitlab_duo/model_context_protocol/mcp_server/">GitLab’s MCP Server </a>offering. This is very useful if your teams live in GitLab and they manage their repositories and pipelines there.</p><p>Similar to GitHub’s offering, it lets your AI agents interact with your projects, by creating and updating issues, merging PRs, and even interacting with your GitLab CI/CD pipelines.</p><h3>3. Azure DevOps MCP Server</h3><p>If your organization is running <a href="https://github.com/microsoft/azure-devops-mcp">Azure DevOps, the MCP server</a> it offers covers the full platform from repositories to work items, builds, releases, and more.</p><p>The ADO MCP Server is maintained by Microsoft and it is actively developed. It offers support for directory-based authentication switching and multi-project management. This is very useful especially if you are managing multiple ADO projects under a single organization.</p><p><strong>Honorable mentions</strong>: <a href="https://plugins.jenkins.io/mcp-server/">Jenkins MCP Server</a></p><h3>Docker and Kubernetes</h3><h3>4. Docker Hub MCP Server</h3><p>Docker Hub server billions of monthly image downloads and hosts over 10 million container images. Finding the right image inside this catalog can be a cumbersome task, as you need to either go through the web UI, or run multiple docker search commands.</p><p>With the <a href="https://www.docker.com/blog/introducing-docker-hub-mcp-server/">Docker Hub MCP server</a>, you can use natural language to enable content discovery, and at the same time, repository management.</p><p>At the same time, with Docker Desktop you get access to more than 200 MCP servers that run directly in Docker, by using the <a href="https://www.docker.com/blog/mcp-toolkit-mcp-servers-that-just-work/">Docker MCP Toolkit</a>.</p><h3>5. Kubernetes MCP Server</h3><p>The <a href="https://github.com/containers/kubernetes-mcp-server">containers/kubernetes-mcp-server</a> supports Kubernetes and OpenShift, and it is available as a native binary, an npm package, a Python package, and even as a container image.</p><p>With this server, your AI agent has full clusters visibility, so you can ask plain-English questions like “Why is this pod failing”, and the agent will come up with a root cause analysis by correlating logs and events, and it will also show you how to solve the issue or apply it automatically.</p><p>The downside to this MCP server is that it doesn’t work natively with cloud providers clusters, so you need to actually have them in your kubeconfig before interacting with them.</p><h3>6. Lens MCP Server</h3><p>The <a href="https://lenshq.io/blog/lens-mcp-server">Lens MCP Server</a> takes Kubernetes management from AI assistants to the next level. Because Lens integrates natively with AWS EKS and Azure AKS, the Lens MCP Server can connect directly to your EKS and AKS clusters, without needing to add them in your kubeconfig.</p><p>At the same time, if you are using the Lens Teamwork feature, the Lens MCP Server will have access to all the clusters that are available in your Lens Teamwork Spaces.</p><p>Example configuration for Claude Code:</p><pre>{<br>&quot;mcpServers&quot;: {<br>  &quot;lens&quot;: {<br>    &quot;command&quot;: &quot;lens&quot;,<br>    &quot;args&quot;: [<br>      &quot;mcp-server&quot;<br>    ]<br>  }<br>}<br>}</pre><h3>7. ArgoCD MCP Server</h3><p>With the <a href="https://github.com/argoproj-labs/mcp-for-argocd">ArgoCD MCP server</a>, your AI assistants can interact with ArgoCD applications through natural language.</p><p>You can list all the clusters that are registered with ArgoCD, list/create/update/delete applications, and also do resource management.</p><p>Example usage in Claude Desktop:</p><pre>{<br> &quot;mcpServers&quot;: {<br>   &quot;argocd-mcp&quot;: {<br>     &quot;command&quot;: &quot;npx&quot;,<br>     &quot;args&quot;: [<br>       &quot;argocd-mcp@latest&quot;,<br>       &quot;stdio&quot;<br>     ],<br>     &quot;env&quot;: {<br>       &quot;ARGOCD_BASE_URL&quot;: &quot;&lt;argocd_url&gt;&quot;,<br>       &quot;ARGOCD_API_TOKEN&quot;: &quot;&lt;argocd_token&gt;&quot;<br>     }<br>   }<br> }<br>}</pre><p><strong>Honorable mentions</strong>: <a href="https://fluxcd.io/blog/2025/05/ai-assisted-gitops/">Flux CD MCP Server</a></p><h3>Infrastructure as Code</h3><h3>8. Terraform MCP Server</h3><p>If you are managing your Terraform code using Terraform Cloud, you can leverage HashiCorp’s <a href="https://developer.hashicorp.com/terraform/mcp-server">Terraform MCP server</a> to interact with all your resources from your AI assistant.</p><p>With the MCP Server, you can manage your workspaces, trigger runs, inspect your state, do cost estimations, and even registry browsing.</p><h3>9. Spacelift Intent</h3><p><a href="https://spacelift.io/platform/intent">Spacelift Intent</a> is an MCP server that lets you manage infrastructure resources directly from your AI assistants.</p><p>You can create/update/delete resources and also import resources that were created outside of your IaC processes. With Spacelift Intent you also ensure that all the resources that were created with AI are tracked, so you can easily manage their lifecycle,</p><h3>10. AWS MCP Server</h3><p>The <a href="https://docs.aws.amazon.com/aws-mcp/latest/userguide/what-is-mcp-server.html">AWS MCP Server</a> (currently in Preview Mode) lets you get real-time AWS knowledge, troubleshoot issues, provision and configure infrastructure and also manage costs.</p><p>This server merges the capability of two existing servers: AWS Knowledge MCP and the AWS API MCP, offering a unified interface that reduces configuration complexity.</p><h3>11. Azure MCP Server</h3><p><a href="https://learn.microsoft.com/en-us/azure/developer/azure-mcp-server/overview">The Azure MCP Server</a> lets you connect your AI agents to your Azure Services. The Azure DevOps MCP server handles the CI/CD side, so this server helps you with your resource management.</p><p>If you are an Azure shop, using these two MCP servers together will unlock an end to end workflow for your infrastructure management.</p><p><strong>Honorable mentions</strong>: <a href="https://www.pulumi.com/docs/ai/mcp-server/">Pulumi MCP Server</a>, <a href="https://github.com/awslabs/mcp/tree/main/src/aws-iac-mcp-server">AWS IaC MCP Server</a></p><h3>Observability</h3><h3>12. Grafana MCP Server</h3><p>With the <a href="https://github.com/grafana/mcp-grafana">Grafana MCP Server</a>, your AI assistant can query data from your dashboards, inspect your data sources, and even retrieve incident details.</p><p>Grafana has optimized how the server structures responses to minimize the context windows usage and to reduce the token costs.</p><p>Example configuration for Claude Desktop:</p><pre>{<br> &quot;mcpServers&quot;: {<br>   &quot;grafana&quot;: {<br>     &quot;command&quot;: &quot;uvx&quot;,<br>     &quot;args&quot;: [&quot;mcp-grafana&quot;],<br>     &quot;env&quot;: {<br>       &quot;GRAFANA_URL&quot;: &quot;http://localhost:3000&quot;,<br>       &quot;GRAFANA_SERVICE_ACCOUNT_TOKEN&quot;: &quot;&lt;your service account token&gt;&quot;<br>     }<br>   }<br> }<br>}</pre><h3>13. Prometheus MCP Server</h3><p><a href="https://hub.docker.com/mcp/server/prometheus/overview">The Prometheus MCP</a> server translates natural language queries into PromQL and executes it against your Prometheus instance.</p><p>Instead of writing complex PromQL, you can just ask your AI assistants to show you different kinds of errors like “show me all 500 error rates for the API server over the last 10 minutes”, and the agent handles the query for you.</p><h3>14. Datadog MCP Server</h3><p>The <a href="https://docs.datadoghq.com/bits_ai/mcp_server/">Datadog MCP Server</a> gives agents access to metrics, logs, traces, and incident management, all through a single interface.</p><p>For organizations that are already paying for Datadog, this server removes a lot of context-switching and can be extremely useful during incident response.</p><p><strong>Honorable mentions</strong>: <a href="https://github.com/getsentry/sentry-mcp">Sentry MCP server</a></p><h3>Security</h3><h3>15. Trivy MCP Server</h3><p>With the <a href="https://github.com/aquasecurity/trivy-mcp">Trivy MCP Server</a> you can enable natural language scanning into your container images, and your infrastructure code.</p><p>Trivy MCP server integrates vulnerability scanning, misconfiguration detection, secret scanning into your resources, and it also supports optional integration with the Aqua Platform for enhanced scanning capabilities.</p><h3>16. Prowler MCP Server</h3><p>Prowler is one of the most widely used open-source cloud security platforms, and its <a href="https://github.com/prowler-cloud/prowler">MCP server </a>is capable of detecting misconfigurations, assessing risks, and automatically generating or submitting remediation pull requests.</p><p><strong>Example configuration:</strong></p><pre>{<br> &quot;mcpServers&quot;: {<br>   &quot;prowler&quot;: {<br>     &quot;type&quot;: &quot;streamable-http&quot;,<br>     &quot;url&quot;: &quot;https://mcp.prowler.com/mcp&quot;<br>   }<br> }<br>}</pre><h3>17. Wiz MCP Server</h3><p>If your organization is running Wiz for cloud security posture management (CSPM), you can use the Wiz MCP server to bring that security context into your development workflow.</p><p>The MCP Server also enhances Wiz Code by translating natural language queries into complement remediation workflows.</p><h3>18. Snyk MCP Server</h3><p>Snyk’s MCP Server is part of the Snyk CLI, which makes it pretty straightforward to get it running. The Snyk MCP server allows MCP-enabled agentic tools to Snyk security scanning capabilities directly.</p><p>With this MCP Server, you can use Snyk scans for code, different configurations, and dependencies, retrieving the results directly into your MCP-enabled tool.</p><p><strong>Honorable Mentions: </strong><a href="https://support.pagerduty.com/main/docs/pagerduty-mcp-server-integration-guide">PagerDuty MCP Server</a>, <a href="https://semgrep.dev/docs/mcp">Semgrep MCP Server</a></p><h3>Best practices before adopting any MCP Server</h3><p>Before you start adopting MCP Servers, and using them in your sensitive environments, you need to keep a couple of things in mind:</p><ul><li>Each server operates with whatever permissions you configure to it; Start with read-only permissions, and offer write capabilities only when you are certain that the agent works as you expect it.</li><li>Don’t give write access to production databases, as the blast radius for an error here can cripple your enterprise</li><li>Configure dedicated service accounts, and IAM roles with leas-privilege policies, rather than reusing your own credentials</li></ul><h3>Conclusion</h3><p>The DevOps MCP ecosystem has grown rapidly over the last 1.5 years. Right now there is a broad ecosystem of enterprise-based and community-maintainted servers covering every major part of the DevOps toolchain.</p><p>While some claim that MCP is dead, and CLI tooling replaces it, the numbers tell a different story. <a href="https://www.pulsemcp.com/servers">PulseMCP</a> alone indexes over 12k MCP servers, and that’s after filtering out low quality implementations. In addition to that, the <a href="https://www.anthropic.com/news/donating-the-model-context-protocol-and-establishing-of-the-agentic-ai-foundation">Linux Foundation stewards the MCP protocol since the end of 2025</a>, which is rarely the kind of thing that happens to dying technologies.</p><p>You shouldn’t pick between MCP and CLI, you should understand that the two aren’t mutually exclusive.</p><p>If you want to manage your Kubernetes clusters easier, give Lens MCP Server a try.</p><p><em>Originally published at </em><a href="https://www.lenshq.io/blog/best-devops-mcp-servers"><em>https://www.lenshq.io</em></a><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=bfde04654a35" width="1" height="1" alt=""><hr><p><a href="https://medium.com/k8slens/18-best-devops-mcp-servers-for-2026-the-definitive-guide-bfde04654a35">18 Best DevOps MCP Servers for 2026 | The Definitive Guide</a> was originally published in <a href="https://medium.com/k8slens">k8slens</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Managing Multi-Cloud Infrastructure with Crossplane and Kubernetes]]></title>
            <link>https://medium.com/k8slens/managing-multi-cloud-infrastructure-with-crossplane-and-kubernetes-68761c38c772?source=rss----1074b70245e3---4</link>
            <guid isPermaLink="false">https://medium.com/p/68761c38c772</guid>
            <category><![CDATA[kubernetes]]></category>
            <category><![CDATA[infrastructure-as-code]]></category>
            <category><![CDATA[tech]]></category>
            <category><![CDATA[crossplane]]></category>
            <category><![CDATA[devops]]></category>
            <dc:creator><![CDATA[Flavius Dinu]]></dc:creator>
            <pubDate>Fri, 27 Mar 2026 07:33:07 GMT</pubDate>
            <atom:updated>2026-03-27T07:33:06.892Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*SOj5QTAfzOQNyVa8IGD9aA.png" /></figure><p>Managing multi-cloud infrastructure has traditionally been associated with Terraform, its open-source alternative OpenTofu, Pulumi, or a mix of vendor-specific infrastructure as code (IaC) tools such as AWS CloudFormation or Azure Bicep.</p><p>Kubernetes (K8s) has evolved far beyond its original use case as a container orchestrator. All major cloud providers now offer Kubernetes operators that can help you manage your infrastructure resource. Your K8s clusters are able to manage S3 buckets, Azure databases, GCP networks, and everything in between.</p><p>These Kubernetes operators are vendor-specific, so for multi-cloud purposes, you need to work with multiple ones. That’s where Crossplane comes in, to be a single solution regardless of the cloud provider.</p><p>In this article we will explore what Crossplane is, how it works, and how you can use it for multi-cloud deployments.</p><p>TL;DR? Check the video instead:</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2FbPL6ciY_1nk%3Ffeature%3Doembed&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DbPL6ciY_1nk&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2FbPL6ciY_1nk%2Fhqdefault.jpg&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/67587c521d844a66540617b873fb3f27/href">https://medium.com/media/67587c521d844a66540617b873fb3f27/href</a></iframe><h3>What is Crossplane and Why does it matter?</h3><p>If you’ve used any IaC tool, you already understand the appeal of declarative infrastructure. You describe what you want with code, and a tool like Terraform makes it happen. Crossplane takes this idea and applies it from Kubernetes. You install Crossplane in your Kubernetes clusters, then use YAML files to declare your IaC and you deploy your cloud resources as Kubernetes custom resources.</p><p>Crossplane uses a reconciliation loop (in the same way that Kubernetes keeps your resources healthy) that ensures your infrastructure converges to the desired state.</p><p>In Crossplane there are a couple of key concepts worth noting:</p><ul><li><strong>Providers</strong>: Similar to Terraform/OpenTofu providers, these are plugins that interact with your Cloud providers. There are many providers available such as AWS, Azure, and GCP, and each provider has its own set of CRDs that represent the cloud resources they can manage.</li><li><strong>Managed Resources (MRs)</strong>: These are similar to Terraform resources; individual cloud resources such as AWS VPC, or an Azure Resource Group. Each of these maps 1:1 to a resource in a cloud providers</li><li><strong>Composite Resources (XRs) and Compositions</strong>: These enable platform teams to abstract complexity away. You can define a CompositeResourceDefinition (XRD) that exposes a simplified API, and a Composition that maps it to one or more MRs.</li><li><strong>Claims: </strong>Namespace-scoped way for team to request infrastructure. With Claims you can trigger the creation of a Composite Resource, which in turn creates the MR.</li></ul><p>With Crossplane you can enable a powerful GitOps-native workflow in which your infrastructure definitions live in Git, your cluster reconciles them continuously, and there is no state file.</p><p><strong>Note: </strong>Not being stateful isn’t necessarily a good thing. At scale, stateful workflows have been proved to work properly for IaC, while there is limited information about non-stateful ones working well at scale.</p><h3>Setting up Crossplane</h3><p>You can install Crossplane in any Kubernetes cluster you want. For this example, I will use a minikube cluster, and we will provision resources across two cloud providers: AWS and Azure.</p><p>Let’s install Crossplane first using Helm:</p><pre>helm repo add crossplane-stable https://charts.crossplane.io/stable<br>helm repo update<br><br>helm install crossplane crossplane-stable/crossplane \<br> --namespace crossplane-system \<br> --create-namespace</pre><p>You can check the status of the installation by using:</p><pre>kubectl get pods -n crossplane-system<br><br>NAME                                       READY   STATUS    RESTARTS   AGE<br>crossplane-7b64857b8d-7ztsg                1/1     Running   0          80s<br>crossplane-rbac-manager-85b5fb85cd-qcsln   1/1     Running   0          80s</pre><p>Both Crossplane and Crossplane RBAC manager should be in a running state.</p><p>Next, install the AWS and Azure providers:</p><pre>apiVersion: pkg.crossplane.io/v1<br>kind: Provider<br>metadata:<br> name: provider-aws<br>spec:<br> package: xpkg.upbound.io/upbound/provider-aws-s3:v1.16.0<br>---<br>apiVersion: pkg.crossplane.io/v1<br>kind: Provider<br>metadata:<br> name: provider-azure<br>spec:<br> package: xpkg.upbound.io/upbound/provider-azure-storage:v1.9.0</pre><p>I’ve saved the configuration from above in a file called <em>providers.yaml.</em> Now, let’s deploy the manifest:</p><pre>kubectl apply -f providers.yaml<br>provider.pkg.crossplane.io/provider-aws created<br>provider.pkg.crossplane.io/provider-azure created</pre><p>By running <em>kubectl get providers</em>, you should see that your providers are healthy.</p><p>Each of these providers needs credentials to interact with its respective cloud. You’ll need to create a Kubernetes Secrets with your cloud credentials, and a ProviderConfig that references it. As a best practice, you should pull these credentials from a secrets management store such as HashiCorp Vault, OpenBao, AWS Secrets Manager, or Azure KeyVault.</p><p>AWS setup:</p><pre>apiVersion: v1<br>kind: Secret<br>metadata:<br> name: aws-creds<br> namespace: crossplane-system<br>type: Opaque<br>stringData:<br> credentials: |<br>   [default]<br>   aws_access_key_id=Your_secret<br>   aws_secret_access_key=Your_secret<br>   aws_session_token=Your_secret (this is optional)<br>---<br>apiVersion: aws.upbound.io/v1beta1<br>kind: ProviderConfig<br>metadata:<br> name: default<br>spec:<br> credentials:<br>   source: Secret<br>   secretRef:<br>     namespace: crossplane-system<br>     name: aws-creds<br>     key: credentials</pre><p>For Azure, you will need to create a service principal like so:</p><pre>az ad sp create-for-rbac \<br> --name &quot;crossplane-provider&quot; \<br> --role Contributor \<br> --scopes /subscriptions/Your_Subscription_ID</pre><p>Make sure you change the subscription ID to reflect your own. Next, you will receive the following output:</p><pre>{<br> &quot;appId&quot;: &quot;...&quot;,<br> &quot;displayName&quot;: &quot;...&quot;,<br> &quot;password&quot;: &quot;...&quot;,<br> &quot;tenant&quot;: &quot;...&quot;,<br>}</pre><p>You will need to map these values like so for the following configuration:</p><ul><li>appID is the clientId</li><li>password is the clientSecret</li><li>tenant is the tenantId</li></ul><pre>apiVersion: v1<br>kind: Secret<br>metadata:<br> name: azure-creds<br> namespace: crossplane-system<br>type: Opaque<br>stringData:<br> credentials: |<br>   {<br>     &quot;clientId&quot;: &quot;YOUR_SECRETS&quot;<br>     &quot;clientSecret&quot;: &quot;YOUR_SECRETS&quot;<br>     &quot;tenantId&quot;: &quot;YOUR_SECRETS&quot;<br>     &quot;subscriptionId&quot;: &quot;YOUR_SECRETS&quot;<br>   }<br>---<br>apiVersion: azure.upbound.io/v1beta1<br>kind: ProviderConfig<br>metadata:<br> name: default<br>spec:<br> credentials:<br>   source: Secret<br>   secretRef:<br>     namespace: crossplane-system<br>     name: azure-creds<br>     key: credentials</pre><p>Now that we’ve set up both providers, we are now ready to create some resources. For this example, I will create an S3 bucket and a Azure resource group:</p><pre>apiVersion: s3.aws.upbound.io/v1beta2<br>kind: Bucket<br>metadata:<br> name: my-lens-crossplane-bucket<br>spec:<br> forProvider:<br>   region: us-east-1<br> providerConfigRef:<br>   name: default</pre><pre>apiVersion: azure.upbound.io/v1beta1<br>kind: ResourceGroup<br>metadata:<br> name: my-crossplane-rg<br>spec:<br> forProvider:<br>   location: East US<br> providerConfigRef:<br>   name: default</pre><p>After you apply these resources, you should be able to view them in your cloud provider. These are just some simple examples, and in most cases, if someone is using Crossplane, they will most likely use a Generic CI/CD to deploy their resources, or a GitOps tool like ArgoCD or FluxCD. In some cases, you will see helm charts that deploy parts of the infrastructure leveraging Crossplane, plus parts of the application using plain Kubernetes manifests. These charts are later on used by CI/CD or dedicated GitOps tools.</p><p>At scale, things become more complicated.</p><p>How do you know what resource you have deployed using Crossplane? It’s very hard to understand what resources have been deployed using Crossplane. You need to run multiple kubectl commands, and this process can be cumbersome. If you are using generic CI/CDs and are deploying hundreds of resources, you will have no visibility whatsoever into what happens. ArgoCD and Flux can help a lot with this, but in some cases, it’s still hard to understand what is actually happening.</p><p>Another important question that you should be aware of is what happens if something fails during provisioning? If this happens, you will need to run multiple kubectl commands to debug, and you will get a wall of text as a response.</p><p>That’s where Lens Kubernetes IDE can help.</p><h3>Observability into your IaC resources with Lens Kubernetes IDE</h3><p>Lens Kubernetes IDE supports CRDs by default, so whenever you install a new CRD into your Kubernetes cluster, it will automatically be visible. You can see, at a glance, what is happening with all your Crossplane resources, and have the ability to filter them, without needing to memorize complicated <em>kubectl commands</em>.</p><p>By clicking on any MR you get a detailed view of its spec, status, and conditions, clearly laid out rather than being buried in terminal outputs. Crossplane’s status conditions are immediately visible so you can spot a failed resource in seconds rather than minutes.</p><p>Lens Kubernetes IDE also has a context-aware AI assistant built in called Lens Prism. With Lens Prism you can ask questions in plain English to understand the status of your resources and it can also help you debug your Crossplane MRs.</p><p>Apart from that, Lens just released an MCP server so you can easily understand from your AI assistants everything that is happening in your cluster, including information about your Crossplane resources. You can connect, for example, Claude Code or Claude Desktop to your Kubernetes clusters through Lens K8s and interact with them naturally. Read more about the Lens MCP Server <a href="https://lenshq.io/blog/lens-mcp-server">here</a>.</p><p>For Crossplane users, this opens up some powerful workflows. Imagine asking your AI assistant:</p><ul><li>Show me all the AWS resources that were provisioned using X Claim</li><li>Are there any Crossplane provider pods that have been restarted in the last 24 hours?</li><li>What MRs are currently not in a Ready state?</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*1c1h4yT_grwDKIst" /></figure><p>The Lens MCP server will translate these natural language queries into K8s API calls, giving you quick answers with context-switching from your editor, terminal, or your AI Desktop application. This is extremely powerful as you get all the information fast, and you are always on top of the state of your infrastructure.</p><h3>Conclusion</h3><p>Crossplane offers Kubernetes the ability to manage your entire infrastructure, but this power without visibility can be a recipe for disaster. You need a way to understand what’s happening, trace relationships, and catch problems early.</p><p>Lens Kubernetes IDE provides exactly that, as it transforms your Crossplane infrastructure into a navigable and understandable system. Combined with Lens Prism and the MCP server, you get a workflow that’s both powerful and approachable.</p><p>If you want to learn more about Lens Kubernetes IDE, <a href="https://www.lenshq.io/contact">book a demo with one of our engineers</a>.</p><p><em>Originally published at </em><a href="https://lenshq.io/blog/crossplane-kubernetes-tutorial"><em>https://lenshq.io</em></a><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=68761c38c772" width="1" height="1" alt=""><hr><p><a href="https://medium.com/k8slens/managing-multi-cloud-infrastructure-with-crossplane-and-kubernetes-68761c38c772">Managing Multi-Cloud Infrastructure with Crossplane and Kubernetes</a> was originally published in <a href="https://medium.com/k8slens">k8slens</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>