Teleport

Whats the difference between AI governance and provable AI governance? More than most teams realize. Leadership needs evidence that the controls work rather than documented policies in the agentic AI era. That's why Teleport's "ISO 42001 Evidence: What Auditors Ask For" caught my attention. ISO 42001 focuses on the management system governing AI across its lifecycle. I would frame the conversation around four questions for boards and executive teams: 1️⃣ Accountability: Can we trace an action to a specific person, pipeline, or AI agent? 2️⃣ Access: Can we show what that identity was permitted to access and what it accessed? 3️⃣ Oversight: Who can review, pause, or override an AI action, and where is the record of that intervention? 4️⃣ Follow through: When something goes wrong, can we demonstrate that corrective action reached completion? A dashboard shows activity and does not demonstrate human oversight. An approval shows intent and does not prove that the approved change is what reached production. AI audit readiness should be an outcome of everyday operations rather than a last-minute documentation exercise. Start with one deployed AI workflow. Ask your team to reconstruct its approvals, access, actions, and oversight from records alone. You have a concrete place to strengthen governance where the trail breaks. Read Teleport's guide to pressure-test your evidence before an auditor does: https://fandf.co/4y82Shb #AIGovernance #ResponsibleAI #Cybersecurity #Teleport #Sponsored #ISO42001 Subscribe to 👉#CXOSpiceNewsletter https://lnkd.in/gy2RJ9xg or 👉 #CXOSpiceYouTube https://lnkd.in/gnMc-Vpj to get the latest updates on #Technology and #Innovation.

In April, Vercel disclosed a breach that started with one click. An employee granted an AI tool "Allow All" access to their Google Workspace. The tool got compromised. The attacker walked in wearing that employee's credentials, pivoted into Vercel's internal systems, and stayed nearly two months before anyone noticed. Two months! The AI tool never had an identity of its own. Its access and the employee's access were the same thing, so you couldn't kill one without killing the other. That's the gap I partnered with Teleport to talk about. Their unified identity layer equips every workload and AI agent with: → Its own identity. The agent stops borrowing yours, so its access dies with its own credentials instead of riding a human's. → Access scoped to the job. Not "Allow All." Just the thing it was provisioned to do. → Credentials issued at runtime that expire on their own, instead of sitting around for two months waiting to be used against you. And every action gets logged under both the agent's identity and the human identity who's answering for it (observability anyone?). So your agent stops being a mystery bot with the keys to everything. Click the link to start a free trial: https://fandf.co/446AJul I'm curious, how are you handling access for your agents right now? #teleportpartner #aiagents #security

Most enterprises now have more machine and agent identities than people, and a large share have already had a breach tied to one. That is a part of the AI agent boom most organizations are still grappling with. We are deploying NHI’s at a scale no human team can track, and we’re handing them the exact thing we spent a decade trying to get rid of, which is long-lived static credentials and standing privileges. Now, an overprivileged agent can exfiltrate data at machine speed all without anyone ever phishing a human. OAuth grants, API tokens, and service accounts are the connective tissue of modern infrastructure, and agents depend on every one of them, and a quarterly access review does very little against something that acts in milliseconds. Agent identity must be treated with the same rigor as human identity, favoring short-lived credentials over static secrets and demanding full auditability of what every agent did and why. That is the shift Resilient Cyber partner Teleport frames as moving from Zero Trust to Agent Trust. Give it a read if you're putting agents into production -> https://fandf.co/4fSCD7E #Sponsored

I recently built an AI SRE agent for a client but it almost got hacked. The agent could investigate incidents, access infrastructure, and take corrective actions. Basically, an SRE that never sleeps. It was doing exactly what we had given it permission to do. - It could access the logs. - It could execute commands. - It could restart services. - It could make changes. - The permissions were restricted. - The access was authenticated. But we still ran into a problem. A malicious prompt injection (an instruction hidden in something the agent was reading) could influence what it decided to do next. The agent wasn't compromised. Nobody stole its credentials. It was simply being influenced by something it was supposed to treat as data. That's when I realized one of the biggest challenges with AI agents isn't just what they're allowed to do, it's what they can be convinced to do. A prompt injection can manipulate an agent into using its legitimate permissions in ways you never intended. I started looking at: → Short-lived, just-in-time access → Strong agent identity → Ephemeral runtimes → Continuous enforcement → Complete auditability → Constraining agent autonomy I figured out Teleport can help me fix this. Instead of giving an agent permanent access to infrastructure, you can build around identity-based, short-lived access and strong session-level visibility. The bigger realization: Zero Trust tells us not to trust the agent by default. Agent Trust asks what happens after we've authenticated it and given it permission to act. That's a very different problem. There is a detailed white paper from Teleport called “From Zero Trust to Agent Trust” that goes deep into this. I learned quite a few things from it, especially around securing autonomous agents operating infrastructure. If you're building AI agents that can touch production, this is worth reading. https://fandf.co/4zU2Qfb Huge thanks to Teleport for making this wonderful resource available and also collaborating on this post.

We spent the last decade drilling specific themes into every engineering org. Eliminate standing access, kill the static credentials, the shared accounts, the long-lived secrets, and give humans short-lived, just-in-time access scoped to what they actually need. Then we started handing AI agents the keys, and quietly threw most of that out the window. Agents are getting provisioned with exactly what we've spent years eliminating for humans. Long-lived API keys, broad standing privileges, credentials baked into a config somewhere, and unlike a human, an agent operates autonomously, at machine speed, across many systems at once. A static credential handed to an agent isn't a shortcut, it’s a standing liability with a much bigger blast radius. The good news is this isn't a new problem, it's the same identity and access problem we already know how to solve. Short-lived credentials over static secrets, least privilege enforced at the infrastructure layer, and real visibility into what every agent accessed, when, and why. The Zero Trust principles we built for humans have to extend to agents, or the model breaks the moment agents touch production. This is the exact problem space Resilient Cyber’s partner Teleport is focused on. Extending identity-based access and strong controls across both human and machine identities as AI moves deeper into infrastructure. Read more on their write-up on Identity Security for AI: https://fandf.co/4xHInZh #Sponsored

Every piece of software is hackable. Every agent needs a security boundary. Every assumption is an attack surface. The Hugging Face incident just triggered a new reset in agentic security. A well-defined agent harness is all anyone needs to perform a denting software hijack. Hugging Face was even using an open-source Chinese LLM to defend its systems. The attack surface has widened so drastically that InfoSec teams still aren't sure what exactly needs to be protected or how far that protection needs to go. From social engineering to prompt injection, from abusing tools to cracking and choking systems, the attack surface is expanding across every layer. And with every release of LLMs (open or closed), they will only get better, cheaper, and more clever. The cost of defending against these swarms of attacks will keep going up, unless you move proactively on this front. For now, what every enterprise can do is at least measure & minimise the surface area: • Pressure-wash your codebase. • Keep the harness simple. • Point agents at specific attack surfaces. • Turn every finding into a new hunting pattern. • Treat every new model as another security researcher. • Make vulnerability hunting continuous. Just like what Teleport did. They let 13 Engineers spend three months finding vulnerabilities with LLMs. Worth a read: https://fandf.co/3T7FvWL Thanks to Teleport for collaborating with me on this post & spreading agentic security awareness.