Dev48
Language
  • About
  • Services
  • Industries
  • Technologies
  • Articles
  • Contacts
Book a call
    Home/Articles/5 key takeaways from security professionals at the all day ai conference 2026
Dev48
info@dev48.org+375 29 320-40-96WhatsApp@isky_by

© 2026 · All rights reserved.

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

Source: Anaconda•November 19, 2026 at 09:15 PM

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

AI agent security means limiting what agents can access, change, or run. See five takeaways from security experts at the All Day AI 2026 conference.

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.

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 .

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.

← All articles

What this article says

More in Software Development

All →
How to read an OCR benchmark before you trust it
Datalab

How to read an OCR benchmark before you trust it

Ignite 2026: Building the frontier ecosystem
Microsoft

Ignite 2026: Building the frontier ecosystem

AI Will Influence $75.8 Billion in Cyber Week 2026 Sales: What Online Sellers Should Know
Ordoro

AI Will Influence $75.8 Billion in Cyber Week 2026 Sales: What Online Sellers Should Know

Amazon Black Friday 2026 Runs 12 Days: What Sellers Need to Know
Ordoro

Amazon Black Friday 2026 Runs 12 Days: What Sellers Need to Know

Elastic and HoneyHive join forces to advance AI observability and evaluation
Elastic

Elastic and HoneyHive join forces to advance AI observability and evaluation

Intuit Reports First-Quarter Results and Enters Agreement to Sell Mailchimp to Bending Spoons
Intuit

Intuit Reports First-Quarter Results and Enters Agreement to Sell Mailchimp to Bending Spoons

More from Anaconda

Kilo Desktop for Data Science and Research Is Now Generally Available
Anaconda

Kilo Desktop for Data Science and Research Is Now Generally Available

Help Your Team Code Faster and Explore Further with Kilo Desktop
Anaconda

Help Your Team Code Faster and Explore Further with Kilo Desktop

AI Red Teaming: What to Test and How to Act on Findings
Anaconda

AI Red Teaming: What to Test and How to Act on Findings

A Fintech Giant Built Across the Americas. Can Your AI Team?
Anaconda

A Fintech Giant Built Across the Americas. Can Your AI Team?

Only 22% of Security Teams in Our Live Tabletop Had a Tested AI Agent Runbook
Anaconda

Only 22% of Security Teams in Our Live Tabletop Had a Tested AI Agent Runbook

Enkrypt AI by Anaconda Named a Sample Vendor for AI Security Testing in Two Gartner® Hype Cycle™ Reports
Anaconda

Enkrypt AI by Anaconda Named a Sample Vendor for AI Security Testing in Two Gartner® Hype Cycle™ Reports