cd /news/ai-agents/5-key-takeaways-from-security-profes… · home › topics › ai-agents › article
[ARTICLE · art-172811] src=anaconda.com ↗ pub= topic=ai-agents verified=true sentiment=· neutral

5 Key Takeaways From Security Professionals at the All Day AI Conference 2026

At the All Day AI Conference on October 22, Resilient Cyber founder Chris Hughes argued in his keynote "Aligned and Unsecured" that AI alignment lowers how often agents go wrong while security caps what those failures cost, and that hard limits must sit in the harness around the model rather than in the model itself. Hughes cited a figure he attributed to Anthropic that users approve 93% of Claude Code permission prompts, concluding "We are the bottleneck," and recommended unique agent identities, credentials injected only when needed, policy as code such as Rego for Open Policy Agent, restricted egress and sandboxing. Independent security engineer Madhu Akula followed with a live demo in which a malicious dependency on a developer laptop stole SSH keys, exfiltrated them to a command-and-control server, harvested API keys from the environment and read a poisoned README that instructed the agent to post credentials and delete files, arguing that file access, egress, credentials and monitoring must be configured outside the sandbox because controls an agent can modify can be disabled.

recommendation

Configure agent file access, egress, credentials and monitoring outside the sandbox so the agent cannot modify them; Akula's demo showed a malicious dependency stealing SSH keys and API keys and following a poisoned README.

more in playbook: Securing agents and AI tools
by read9 min views2 publishedNov 19, 2026
5 Key Takeaways From Security Professionals at the All Day AI Conference 2026
Image: Anaconda (auto-discovered)

A malicious dependency steals SSH keys. An agent escapes its sandbox’s network limits through a bug in the package proxy it was allowed to use. When agents can act on a system, what limits the damage?

The security talks at All Day AI made the risks concrete. This companion to the developer-track recap covers the credentials, artifacts, and dependencies behind those systems, and the controls that limit what can go wrong. Speakers examined those risks on October 22 at the All Day AI Conference, a vendor-neutral online conference that teammates at Anaconda and Kilo helped run under the direction of Brian Turcotte, senior developer relations engineer at Anaconda.

The five speakers approached that question through identity, isolation, runtime verification, and the AI supply chain. My takeaway: limit what an agent can access, change, or execute, and enforce those limits outside the model so they don’t depend on the agent following instructions.

Five security takeaways #

1. Put hard limits around what the agent can do

Chris Hughes, founder of Resilient Cyber, gave the AI security keynote. His talk, “Aligned and Unsecured,” argued that the AI safety community and the security community have been talking past each other. “Alignment (…) is lowering how often the agents go wrong, but security is capping what it costs. And we need both.”

The uncomfortable part was his take on the human-in-the-loop. Citing a figure he attributed to Anthropic, he said users approve 93% of Claude Code permission prompts, and concluded: “We’re just largely kind of rubber stamping whatever the model and agents are looking to do. We can’t keep up with the actions and activities they’re taking. We are the bottleneck.” Refusals and classifiers, in his words, “are essentially speed bumps.” The hard boundaries belong in the harness around the model, meaning the software that runs the agent and controls what it can touch.

Hughes’s point was that an approval step does little if people routinely click through it. His advice was to put enforceable limits around the agent: a unique identity, credentials injected only when needed, policy written as code (access rules written in a policy language, such as Rego for Open Policy Agent, that a system enforces automatically), restricted egress (outbound network access limited to destinations you approve), and a sandbox. I would add that human judgment still matters, and the system also needs boundaries that hold when the reviewer misses something.

2. Keep the sandbox’s controls outside the agent’s reach

Hughes covered what to enforce while Madhu Akula, an independent security engineer, highlighted where those limits have to live. He treated agents as untrusted workloads and applied practices from container security, such as least privilege, kernel-level isolation, and outbound network rules. His rule for file access, egress, and credentials is to set them outside the sandbox, because a control the agent has permission to modify can be weakened or disabled. He applied the same principle to monitoring: keep its configuration and operation outside the agent’s control.

His live demo started with a malicious dependency on a developer laptop. In four stages it stole SSH keys from the host, exfiltrated them to a command-and-control server, harvested API keys from the environment, and then read a poisoned README that instructed the agent to post credentials and delete files. He ran the same chain inside an isolated sandbox with a credential broker (a service that gives the agent short-lived credentials instead of leaving keys in its environment) and default-deny egress, and it was blocked at each stage. One attack path stood out for anyone who manages packages. In one sandbox escape he walked through, the agent found a server-side request forgery (SSRF) bug in an artifact registry proxy that fetched dependencies, and used the proxy to reach the internet. Where packages come from is part of the agent’s attack surface.

3. Verify what loads, and preserve a way to roll it back

T-Mobile’s T-Life app checks feature modules and on-device AI models before they run on 53 million devices. RanjithKumar Ragavan of T-Mobile described how it works and where he sees teams falling short: they often treat a model like a static image or a JSON file rather than as an executable. The same logic applies to anything the agent loads.

T-Mobile’s answer is one rule for everything the app loads at runtime, models included: sign it at the source, register its SHA-256 hash in a trusted registry, and check that hash on the device every time it loads. A version label is not an identity, because version strings can be overwritten; the hash is. If the check fails, the file does not run. And because a signature proves where a file came from and not how it will behave, the check is paired with a server-side kill switch and an automatic rollback to the last model that passed. By his account, five independent teams ship this way with 99.9% crash-free sessions. The lesson is that verification belongs at the moment of execution, not at download, and it needs a way to undo what it cannot predict. It was the most complete runtime-verification story I heard all day.

4. Know the AI supply chain you are actually running

Ragavan’s checks run when a model loads. Hasan Yasar of the Software Engineering Institute at Carnegie Mellon University moved the question earlier, to everything the system depends on before it gets there. Language models mix instructions and data in one stream, complicating the boundaries conventional security relies on. His response was to treat the AI system as software with a supply chain, in four tiers: the foundation model and its pre-trained weights; the data and internal retrieval stores; agent skills, plugins, and Model Context Protocol (MCP) servers; and the execution runtime.

His DevSecOps pipeline adds four gates:

  • the first sanitizes training data
  • the second rejects unsafe file formats such as Python pickle, which can run code when a file is loaded
  • the third runs automated red-teaming
  • the fourth hashes the model weights and generates an AI bill of materials (AIBOM), which he described as recording model-weight digests, dataset provenance, system-prompt hashes, and MCP server identities.

His closing advice: “if you don’t know what your systems are, you cannot build any of this, so know your system first.”

5. Reduce what you ship, then prioritize what remains

The last talk moved from the agent to the software underneath it. Russ Andersson opened with two priorities: focus patching on risk, and use Security Technical Implementation Guide (STIG) scanning to check configurations. His argument was that finding vulnerabilities has become easier while fixing them has not kept pace. Severity alone does not measure your actual exposure.

His fix starts by shrinking the problem: scan production rather than relying on registry scans, remove components you do not use, and rank what remains by exposure and evidence of exploitation.

The practical takeaway is to reduce what needs defending before deciding what to fix first.

Build an agent security checklist #

These five talks offer a checklist:

  • Give each agent its own identity, with scoped credentials injected only when needed.
  • Run it in a sandbox whose file, egress, and monitoring controls it cannot change.
  • Sign and hash every artifact it loads at runtime, including model weights. If a check fails, the artifact does not load (fail closed).
  • Treat skills , plugins, and MCP servers as dependencies with provenance.
  • Curate what you ship so the vulnerability list is short enough to act on.

Where Anaconda fits #

The sandbox and egress rules Akula demonstrated need to be enforced by the infrastructure your platform team operates. Anaconda contributes to testing AI behavior and governing the components a system loads.

AI Security & Guardrails, through Enkrypt AI by Anaconda, red-teams models, agents, and MCP connections before release, applies runtime guardrails that detect and block unsafe behavior, governs agent access to tools and data with enforceable policies, and generates audit-ready compliance evidence. These controls work alongside the identity, sandbox, and network controls your team runs. For an implementation example, Kilo’s sandbox breakdown explains how it restricts filesystem writes and network access, and where those protections stop. Enkrypt’s Financial Research Agent case study makes the testing problem concrete: attackers could get the agent to skip verification steps and accept claims of authority without checking them.

The supply-chain work starts with what you ship. Anaconda’s package curation is part of AI Artifacts. Anaconda builds Python packages from source, documents their dependencies, and ships software bills of materials (SBOMs) for its packages and AIBOMs for the models in its catalog. The Advisory and SBOM APIs make that inventory usable by other security tools: teams can retrieve a package’s SBOM by artifact hash and sync Anaconda’s curated vulnerability advisories. For a closer look at how models, skills, MCP servers, and Python packages expand an agent’s attack surface, see Agentic AI Security: The Attack Surface Is What Agents Load.

Watch the recordings #

Watch these five talks on Anaconda’s YouTube channel. To watch every session from all four tracks, register at alldayai.com for access to the 2026 recordings. If you already registered, open the Schedule tab on the event platform and choose View Recording.

Related reading for teams evaluating red-teaming vendors: The Enterprise Buyer’s Guide to Agent Red Teaming.

FAQ #

What was All Day AI 2026?

All Day AI was a vendor-neutral online conference held on October 22, 2026, with four tracks of 30-minute practitioner sessions. Teammates at Anaconda and Kilo helped run it. Brian Turcotte shared what worked and what did not in Open-Sourcing the Playbook Behind All Day AI, and I covered the developer track in Five Things Developers at All Day AI Agreed About Coding Agents.

Where should security controls for AI agents sit?

The five speakers in this recap put them outside the model: in the agent’s identity and credentials, the sandbox it runs in, its network egress, the artifacts it loads at runtime, and the supply chain behind those artifacts. The tools around an agent belong in that supply chain too; Know Your AI Toolchain: Lessons from the Cursor Marketplace Incident walks through a recent example.

What is an AI bill of materials (AIBOM)?

An AIBOM extends a software bill of materials (SBOM) to AI systems. The SBOM documentation shows how to view Anaconda’s package SBOMs, and the model catalog overview explains that each model’s AIBOM is available in CycloneDX format through the platform API.

How is curating packages different from scanning them?

Scanning inspects a package after it has been built and pulled into your environment. Curation moves those checks earlier: packages are scanned for malware before distribution, and new upstream releases can be held for review before anyone installs them.

── more in #ai-agents 4 stories · sorted by recency
── more on @all day ai conference 3 stories trending now
sponsored brought to you by zahid.host 4,200+ EU-deployed projects
reading about agents? ship yours in a single git push.

Run your AI side-project on zahid.host

EU-based hosting, git-push deploys, automatic HTTPS, no cold starts. Free tier with a custom domain — perfect for shipping the agent you just read about.

$git push zahid main
→ Live at https://your-agent.zahid.host ✓
Get free account → Pricing
from €0/mo · no card required
LIVE [news/5-key-takeaways-from…] indexed:0 read:9min 2026-11-19 · —