Skip to content
PodSubs
ShowsPeopleGuestsJobsNewsEvents
More
BlogPodCred
Menu
ShowsPeopleGuestsJobsNewsEventsBlogPodCredNetworksSign in
Join nowSign in
  • Shows
  • People
  • Jobs
  • News
  • More
    • Guests
    • Events
    • Blog
    • PodCred
    • Networks
    Join nowSign in

DevOps Academy Podcast

DevOps Academy Podcast artwork

DevOps Academy S1E21: Shadow AI Is Becoming the New Shadow IT — Do You Know What Agents Are Running in Your Organization?

Nov 9, 202623 minAudioSeason 1, Episode 21
ShareXLinkedInFacebookWhatsAppEmail

Your engineering team may be using more AI tools than you realize. But do you know which ones have access to your code, credentials, and production systems? From AI coding assistants and locally running models to autonomous agents and unofficial automations, Shadow AI is becoming a growing challenge for engineering organizations. Developers are adopting AI tools to move faster, but many of these tools operate outside traditional IT approval processes, security monitoring, and governance frameworks. In this episode of DevOps Academy Deep Dive, we explore how Shadow AI is evolving beyond unapproved chatbots into AI agents that can access repositories, interact with infrastructure, process sensitive information, and execute recurring workflows. We discuss the risks of unmanaged AI tools, hidden credentials, unknown dependencies, and agents that quietly become part of production operations. We also examine how DevOps, platform engineering, and security teams can gain visibility into AI adoption without restricting innovation or slowing developers down. 🔑 Key Takeaways What Shadow AI is and how it differs from traditional Shadow IT Why AI agents create new visibility and governance challenges How unofficial AI tools gain access to repositories, credentials, and infrastructure The risks of unmanaged AI agents running automated workflows How organizations can discover and inventory AI tools When an AI experiment becomes an operational dependency The hidden costs of duplicate AI tools and fragmented adoption The importance of approved AI tool catalogs and clear ownership Why high-impact AI agents need independent shutdown controls How to bring useful unofficial AI tools into managed environments Balancing developer innovation with security and operational accountability 🎧 Tune in to discover why the biggest AI security risk may not be the agents your organization has approved, but the ones it doesn't even know exist. 💬 If you had to identify every AI agent accessing your company's systems tomorrow, could you?

Audio and video play straight from the show's own hosting. PodSubs stores and serves no media.

Transcript

From the show. Tap a time to play from there.

So the biggest threat to your company's digital security right now, it isn't actually some shadowy hacker in a hoodie operating out of a basement. Right, it's definitely not. Yeah, it's actually your best engineer sitting right there in the office just trying to save, I don't know, maybe three hours of tedious work on a random Tuesday. Because it usually starts with just a minor annoyance, you know, a developer is tired of manually analyzing error logs or writing the same boilerplate code over and over again. Oh, yeah, we've all been there. Exactly. So they find a new AI tool online that promises to automate all that busy work,

they install it, and suddenly they are twice as productive. And then they tell their entire team about it on Slack. Yep. And by Friday, half the engineering department is using it. Which brings us to the core of our deep dive into the source material today. We are unpacking a really fascinating, highly detailed set of notes titled, Shadow AIs Becoming the New Shadow IT. Do you know what agents are running inside your engineering organization? It's a great title because it asks the exact right question. Right. And our mission today is to explore this massive invisible gap.

We're looking at the delta between the AI tools a company's leadership thinks they are using and the autonomous agents that are actually running in the shadows of their infrastructure right now. It represents a pretty profound shift in organizational risk. I mean, for the last 20 years, IT departments dealt with shadow IT. Employees using unapproved file sharing apps or project management software. Sure, like signing up for a random web tool. Exactly. But the introduction of autonomous AI agents, it fundamentally rewrites the physics of that risk. So whether you are

an engineering leader trying to wrap your head around securing a network, a developer who just wants to get things done without a mountain of red tape, or if you're just fiercely curious about how tech is actually adopted when the boss isn't looking, this deep dive is for you. There's a lot to cover here. It really is. We are going to unpack why this invisible AI adoption is happening everywhere, why it's usually born out of good intentions rather than malice, and how it is forcing a complete redesign of enterprise security. To set the baseline, the sources define shadow

AI as any AI tools, models, services, or automated workflows being utilized by employees without organizational visibility, official approval, or formal governance. Which sounds like standard shadow IT. But the critical distinction to make right away is the escalation in capabilities. OK, let's unpack this and frame that escalation. Because traditional shadow IT, that was sort of like an employee sneaking an unapproved filing cabinet into the office, right? That's a good way to look at it. It's against the rules. It

bypasses compliance. But at the end of the day, it's just a passive box sitting in the corner. But shadow AI? That's like sneaking in an invisible intern who immediately starts reading your confidential files, reorganizing them, and sending emails on your behalf without even asking. That analogy hits on the defining characteristic of this shift, which is agency. Agency, right. A few years ago, the primary enterprise concern around AI was data leakage. Specifically, an employee copying and pasting sensitive company data into a public web -based chatbot. Right. We all remember those

set lines. Exactly. But a chatbot is generally passive. It receives text, processes it, and generates tech back. You have to prompt it every single step of the way. You're doing the driving. Right. But engineering teams have rapidly moved beyond chatbots into the era of agents. And an agent doesn't just talk to you. It executes tasks across multiple platforms. It acts on its own logic. Agents are specifically designed to interact with external systems through application programming interfaces, or PPIs. They're actually doing things.

Oh, absolutely. They are built to autonomously search through your code repositories, analyze the findings, automatically create pull requests to alter that code, run command line scripts, query databases. They make decisions based on the state of your environment. That's a huge leap from just a chat window, and the source of single out engineering organizations is being uniquely exposed to this specific risk. Why is an unapproved AI agent in the engineering department fundamentally more dangerous than one in, say,

marketing or accounting? Well, it comes down to system access. Engineers hold the keys to the kingdom. Right. They have the passwords to everything. They have legitimate, highly privileged access to the most critical systems in the company. We're talking about raw proprietary source code, the cloud deployment environments where your applications live, internal APIs, production databases containing customer information. Basically, the crown jewels. Exactly. And the continuous integration pipelines, which, if you're not in the weeds every day, is essentially the automated

assembly line where your company's code is compiled, tested, and pushed live to the internet. Got it. So when an engineer introduces an AI agent to help them work, that agent invariably operates with that specific engineer's level of administrative access. Let's ground this in a specific example so you, the listener, can really visualize the mechanics of this. Let's say I'm a cloud infrastructure engineer. And I find a slick, unapproved AI tool online that promises to optimize my Terraform configurations. Okay, the code that defines how all the company's cloud servers and networks

are built. Exactly. So I plug it in and it starts suggesting brilliant improvements. I look like a total genius in our weekly sprint review. You do, but you've also just introduced a black box into the core of your infrastructure. Uh -oh. Because the tool doesn't just read a static text file. To make those... brilliant suggestions, it has to pull in your environment variables to understand how your servers connect. It needs to look at your network routing. Oh, wow. I didn't even think about that. Right. From a security standpoint, the unapproved tool is now digesting your entire architectural blueprint. Are they

using your proprietary infrastructure layout to train their next public model? Which is a terrifying thought. It gets worse. More importantly, did the AI agent subtly introduce a new, unvetted, open -source software dependency into your environment just to make its suggested optimization work? And the developer wouldn't even notice. Exactly. The developers focused entirely on the productivity gain. They aren't evaluating the supply chain risk at all. Which opens up a huge mechanical question here. If these AI agents are operating as invisible interns, how are they actually getting

their own set of keys to the building? Like, an external AI startup doesn't magically have a login to our corporate AWS environment. No, they don't. The notes refer to this as the credential problem, and it is perhaps the most significant blind spot in modern enterprise engineering today. The credential problem. Yeah. To bridge the gap between an unapproved AI agent and the company's internal systems, developers are leveraging personal access tokens, commonly known as PATs. Okay, let's explain the mechanics of a PAT really quick.

Because the issue with personal access tokens isn't just that they act as a password. It's that developers are generating these tokens with indefinite lifespans and zero multi -factor authentication. Basically bypassing the entire corporate single sign -on security layer. And that is the absolute crux of the vulnerability. Right. Think about it. A developer logs into their enterprise code repository. goes into their developer settings, clicks generate token, and often they just check every single permission box available. Because it's faster than figuring out what the tool actually

needs. Exactly. It's faster than figuring out the exact principle of least privilege required for that specific AI tool. So they take that incredibly powerful string of characters and paste it right into the plaintext configuration file of their new unvetted AI agent. So now you have a third party agent operating completely outside of organizational visibility possessing a master skeleton key that can read, write, or delete corporate assets, and that key never expires. And this creates an absolute nightmare for security

audits. I can imagine. Imagine a security engineer is running a routine credential audit. They see your active token in the logs. Because it's tied to your user identity, they have absolutely no idea that an autonomous AI agent is actually the entity using it to perform hundreds of automated tasks every hour. Wait, let me stop you there and push back on this a bit because I can hear some of our technical listeners formulating an argument right now. Okay, let's hear it. If I build a small, helpful AI automation, and it's just running locally on my own physical work

laptop, I have a really hard time accepting that this is a critical threat. I mean, production infrastructure is what we officially package up, put through staging, and deploy to a managed server cluster. My laptop is not production. It's a very common defense. But it requires a complete reversal of how the industry traditionally defines production. How so? The physical or virtual location where the code executes simply doesn't matter anymore. It is the impact of the code that defines what constitutes production infrastructure.

Okay, walk me through that. Think about the mechanics of what that local agent might be doing. Let's say you have a Python script running on your laptop that uses a local AI model to query a shared company database. clean up the formatting of new customer entries and push the updates back to the live database every 10 minutes. OK, so it's doing sort of janitorial work on the live data. Right. Now, what happens if your laptop battery dies or you go on vacation and close the lid? Oh, the janitorial work stops? Exactly.

Mm -hmm. If a business process begins to fail or data quality degrades because your specific machine goes offline, then your laptop is, by definition, load -bearing production infrastructure. Wow, I never thought of it that way. Yeah, you have effectively deployed a critical service on consumer hardware without any of the resilience, load balancing, or security monitoring that a real production environment mandates. That makes a lot of sense when you frame it around business continuity. But I want to dig into the local

model aspect because a lot of developers specifically choose to run local AI models like downloading a smaller open source model directly to their hard drive. specifically to avoid sending proprietary data out to external cloud providers. They feel like they're doing the responsible thing. And they are solving one specific problem, external data exfiltration, but creating several others in the process. Really? Like what? Well, local models are explicitly not a silver bullet for shadow AI. First, running a local model requires

significant compute power. often taxing shared internal network resources if it begins aggressively indexing internal wikis or code bases to build its context window. So it's quietly eating up the network bandwidth. Yes. And second, and this is more importantly, a local model still has full access to the local file system on that machine. Oh, right. It's on the hard drive. Exactly. If the developer gives the agent tools to query the internal network, it could inadvertently index sensitive HR files located on an open internal

shared drive. Yikes. And then it uses that highly confidential context to answer a casual prompt from the developer. The core issue isn't where the model is hosted. The issue is what internal APIs the system can interact with and what automated decisions it is authorized to execute. So if these local agents are secretly acting as load -bearing infrastructure, what happens when the human engineer goes to sleep? but the system inevitably hits a critical error at, I don't know, 2 a .m. This is where we encounter the

ghost in the machine scenario, and it is a total nightmare for incident response teams. Ghost in the machine. That sounds ominous. It is. Imagine a critical production system starts behaving strangely in the middle of the night. An on -call DevOps engineer logs in, investigates the telemetry, and discovers that a vital routing configuration file has drifted from its correct state. Okay. Pretty standard late night emergency so far. Right. So they manually correct the file, verify the system is stable, and go to make a cup of

coffee. But because we are talking about shadow AI, I'm guessing the fix doesn't hold. Not at all. Five minutes later, the system alerts again. The configuration file has been reverted back to the broken state. Wait, it just changes it back? Yes. And because the DevOps team has no visibility into the fact that an unofficial AI automation exists, They misdiagnose the entire situation. They assume it's a deep -seated bug in their deployment pipeline, a failing database cluster, or maybe even an active intrusion by

a malicious actor. When in reality, they are just fighting a turf war with an invisible intern. Exactly. Mechanistically, what is happening is the Shadow AI agent is running on a continuous polling loop. It's constantly checking the system's actual state against what its underlying model insists the state should be. Oh, I see. So when the human engineer fixed the configuration, the agent's next polling cycle woke up, detected a discrepancy between the live file and its internal instructions, and aggressively fixed the file back to the broken state. Well, here's where

it gets really interesting. Because depending on an AI agent to voluntarily shut itself down during a security incident, that's basically like asking a runaway train to please apply its own brakes. It just doesn't work. It really doesn't. A true architectural kill switch isn't a polite request. It is instantly deactivating their key card so they can't open any more doors regardless of what their internal logic is telling them to do. You just pulled a plug on the access. Right. The source material emphasizes that operational control must exist entirely outside of the agent's

own cognitive loop. A kill switch means having the architectural authority to instantly revoke those personal access tokens the agent is using. Oh, so you just kill the PAT. Exactly. Or it means firewalling off the specific API endpoints the agent talks to. Even if the AI has a queue of 50 pending tasks it is determined to execute. Revoking the architectural permissions halts those tasks in their tracks. That brings up a terrifying hypothetical. What happens if the

developer who built this complex polling AI agent just, you know, gets a new job and leaves the company? You're touching on the massive liability of orphan systems. Orphan systems. Yeah. So a developer builds an unapproved AI workflow. And to make it persistent, they don't tie it to their personal laptop. They tie it to an unmonitored service account on some forgotten testing server in the cloud. And then they quit. Then they quit. That automation just keeps running in the dark. It is completely undocumented. Nobody remaining

at the company knows why it exists, what data it processes, or how it even makes decisions. It's basically just a ticking time bomb at that point. Mechanistically, it will eventually fail. An internal API it relies on will be updated, and the payload structure will change. And the agent won't know what to do. Right. The agent won't understand the new format. So it will start hallucinating, perhaps spamming internal Slack channels with gibberish. Or infinitely retrying a failed API call until it exhausts the department's monthly cloud compute budget in a matter of hours.

Oh my god, the cloud pill. Yeah, a core business process fails and nobody in the building even understands the architecture of the system that just brought them down. Well, if I'm listening to this right now and I manage an engineering team, my immediate visceral instinct is to lock everything down. ban all unapproved AI sites at the corporate firewall, put endpoint detection software on every laptop to block local models. If you tell me the threat is this invisible and this pervasive, banning it feels like the only

responsible action. It definitely feels responsible. But the data in the sources firmly indicates that sweeping bans are the worst possible reaction. Really? Yeah. The worst. Yeah. Bans do not eliminate the behavior. They merely push the usage further underground. It transforms a visibility problem into a massive legal and compliance disaster. So what does this all mean for the listener? Walk me through the mechanics of that backfire. If bans don't work, should companies just start spying on their developers to find these tools? Definitely not. Employee surveillance, like inspecting

every AI prompt, is a huge privacy violation and destroys culture. Discovery actually requires trust. Trust. OK. If developers believe that bringing a highly effective time -saving tool to the security team's attention will result in an automatic ban, they will simply bypass the security team. Right. They'll just hide it better. Exactly. When you block generative AI tools at the corporate network level, developers don't stop using them. They just switch off the corporate VPN. They use their personal cell phones,

or they run the code through consumer -grade AI accounts on their home networks. And a personal consumer account has radically different data handling agreements than an enterprise contract. Radically different. Enterprise agreements explicitly include strict clauses prohibiting the AI provider from using your corporate data to train their public model. Which is what you want. Right. But consumer terms of service almost always grant the provider the right to ingest that data for training. By implementing a blanket ban, you have inadvertently forced your developers to copy and paste proprietary source code. and potentially

regulated customer data directly into consumer -grade environments where you have zero legal protection or audit capability. Okay, so spying on employees is out, and blanket bans actively destroy compliance. How is a company supposed to govern this? The paradigm shift here is to view shadow AI not strictly as a security breach, but as a very loud signal. A signal of what? It is a flashing neon sign pointing directly to unmet developer needs. If the security audit discovers that three completely separate teams

within your organization have independently built unapproved unofficial AI tools to automate their code reviews, then clearly the platform team needs to buy or build a standardized code review assistant because the engineers are desperate for it. Precisely. The unauthorized usage is highlighting a tooling deficit. Furthermore, Shadow AI creates a massive hidden financial burden. Oh, because everyone is buying their own stuff? Yes. If everyone is expensing their own random AI subscriptions on corporate cards,

you have fragmented spending, duplicate tools solving the exact same problem, and overlapping maintenance burdens. The strategic solution proposed in the sources is risk -based governance. Okay, break down risk -based governance for me. How does an organization actually implement that on a Tuesday morning? It begins by acknowledging that not All AI usage carries the same risk profile. If a developer wants to use an AI tool to generate boilerplate documentation based entirely on open source, publicly available information, the risk

is incredibly low. So that should be easy to approve. Right. That usage should be fast -tracked with almost zero administrative friction. However, if a developer wants to deploy an agent that requires access to modify production cloud infrastructure, that requires rigorous review, centralized logging, and strict temporary credential management. Makes sense. You don't treat the intern organizing the public lobby the same way you treat the intern who needs access to the bank vault. That's a great way to put it. To operationalize this, organizations need to build an approved AI tool

catalog. Think of it as an internal developer portal. Like an app store for the company. Basically. Instead of a developer wasting hours researching random tools on Reddit and guessing what might trigger a security alert, they go to this internal portal. The catalog tells them exactly which AI tools have already been vetted, what classification of internal data those tools are legally allowed to process, and provides an automated click -to -install method for gaining access immediately. You essentially make doing the secure thing the

easiest and fastest option available. Exactly. You pave a road for innovation. And if the paved road is smooth and gets them to their destination faster, they will naturally stop off -roading through the shadows. That is the ultimate goal. You cannot secure. you cannot govern, and you cannot properly operate an AI agent that you do not know exists. This has been a profoundly eye -opening deep dive. Let's recap what we've unpacked today. We started by exploring how the threat landscape has evolved from simple data

leakage and chatbots to autonomous agents that act on their own logic and interface directly with APIs. A huge shift in capability. Yeah. And we dismantled the myth that code running on a local laptop isn't production infrastructure, highlighting how unmanaged personal access tokens bypass core security layers to give these agents the keys to the kingdom. We walk through the incident response nightmares of ghosts in the machine, constantly reverting fixes, and we establish why blanket bans actually destroy data compliance

by pushing proprietary code into consumer -grade accounts. It's all connected. It really is. Ultimately, The goal isn't to crush experimentation, but to provide a visible, secure, and paved road for that innovation. It is about bringing the invisible intern out into the light, assigning them an official corporate identity, and ensuring their access is strictly controlled by architectural kill switchers. Absolutely. I want to turn this directly back to you, the listener, right now. I want you to critically evaluate your own engineering

organization. Think about the workflows you rely on every day. Good exercise. If your company's leadership mandated that you had to identify and audit every single AI agent currently possessing read or write access to your internal systems, by tomorrow morning, could you actually do it? Or are there invisible interns running in the background right now? Given the rapid proliferation of these tools, I think most organizations would struggle to find even half of them. And that leads me to one final deeply unsettling thought for you to take away. We explored the cascading

failures caused by orphan systems when an employee leaves the company, leaving their automated agent running in the dark on a forgotten service account. But consider the trajectory of this technology. It's moving so fast. AI agents are becoming increasingly autonomous and they already possess the ability to write and execute their own code. They are rapidly gaining the cognitive architecture required to synthesize new tools to solve novel problems. So what happens when that Unmanaged, orphaned,

invisible in turn hits a complex roadblock and instead of failing, it autonomously decides to generate, configure, and deploy an entirely new sub -agent to help it complete its task. Who owns the security, the compliance, and the output of a shadow AI that was hallucinated into existence by another shadow AI deep within a corporate network that nobody even knew was compromised in the first place? Something for you to mull over the next time a background process quietly updates itself.

Open the transcript file

Hosts and Guests

Nobody is credited on this episode yet.

Credit the people on this episode

Be the first to rate this episode

More episodes

All episodes
  1. DevOps Academy S1E22: Platform Engineering 2.0 — Are Internal Developer Platforms Becoming AI Platforms?

    Nov 16, 202628 minAudio

    Internal Developer Platforms were built to simplify software development. But as engineering teams begin building AI-powered applications, are traditional developer platforms ready for what comes next? From integrating...

    Credit the people on this episode

  2. DevOps Academy S1E20: MCP in Production — Are AI Agents Creating a New Infrastructure Security Boundary?

    Nov 2, 202622 minAudio

    AI agents are moving beyond generating answers. They're connecting to real infrastructure, accessing internal systems, and interacting with production environments. But who controls what they're allowed to do? The Model...

    Credit the people on this episode

  3. DevOps Academy Deep Dive S1E19: AI Workloads Fail Differently — Is Traditional SRE Enough for Production AI?

    Oct 26, 202623 minAudio

    What happens when your AI application is running perfectly, but its answers are wrong? Traditional Site Reliability Engineering focuses on availability, latency, error rates, and infrastructure performance. But...

    Credit the people on this episode

  4. DevOps Academy Deep Dive S1E18: AI Is Making Developers Faster — Is Infrastructure Becoming the New Bottleneck?

    Oct 19, 202623 minAudio

    AI coding assistants are helping developers write code, generate tests, and build applications faster than ever. But is the rest of the software delivery process keeping up? In this episode of DevOps Academy Deep Dive,...

    Credit the people on this episode

  5. DevOps Academy Deep Dive S1E16: eBPF and the Future of Observability — Can We Monitor Systems Without Instrumenting Everything?

    Sep 29, 202620 minAudio

    Modern engineering teams collect more telemetry than ever, yet getting meaningful visibility into production can still require extensive application instrumentation. In this episode of DevOps Academy Deep Dive, we...

    Credit the people on this episode