Security, isolation and multi-tenancy
When the code in a sandbox is hostile, the isolation boundary is the product. These posts cover hardware versus kernel-level isolation, multi-tenant platform design, prompt injection and supply-chain attacks against agents, egress control, and the evidence auditors ask for.
PandaStack security312 posts
Every In-Process Python Sandbox Leaks, and the Reason Is Structural
Removing a name from a namespace removes a name, not reachability. CPython's object graph has no partitions, and `ctypes` is a documented feature whose purpose is calling arbitrary native code. Here is where the boundary actually has to go.
Encryption at Rest for Sandbox Disks and Snapshots
"Is customer data encrypted at rest?" is one checkbox covering four very different files, three of which are not what the reviewer is picturing. One of them is a verbatim copy of someone's RAM.
Pickle Is a Virtual Machine You Have Been Downloading
pickle is a stack machine with an eval loop, and you have been downloading it from the internet as model weights. Here is the disassembly, why the allowlist promises less than it looks, and the conversion gateway that fixes it once instead of forever.
Giving an AI Agent a Language Server: The Index Is Code Execution
An agent that edits code by grepping and guessing is the agent everyone complains about. A language server fixes that — and quietly runs the repository's build scripts to do it. So run the indexer in a microVM, snapshot the warm index, and restore it per session.
Where to Run devcontainer.json in 2026
devcontainer.json names an image, layers features, forwards ports and runs lifecycle commands. It has no field describing what the workspace is isolated from — so two fully compliant platforms can hand you completely different blast radii from a byte-identical file.
Top 10 Throwaway psql Platforms for Engineers (2026)
Everyone benchmarks create latency. Nobody benchmarks the part engineers actually wait on, which is the seed. A database you can create in two seconds and must then load 40 GB into is a twenty-minute database -- so grade these ten on the provisioning verb instead.
Parsing Untrusted XML: The Format That Ships an Interpreter
An external entity is a documented feature that makes the parser read files and open sockets for whoever wrote the document. XXE is not a defect; it is conformance with the wrong author. So stop treating a flag as a boundary.
Per-Tenant Audio and DSP Rendering in MicroVMs: The Plugin Is the Payload
Audio platforms have the same shape as render farms, plus one property that changes everything: the thing a customer uploads is often not data, it is a shared library, and hosting it means loading it into your renderer's address space.
Running a Multi-Tenant Render Farm on MicroVMs: A .blend File Is a Program
If strangers send you scene files and render flags, you are not running a render farm. You are running a code-execution platform that happens to produce images, and the boundary you picked for "just rendering" is now load-bearing.
More posts in this topic
- Bioinformatics Pipelines on microVMs: Reproducibility, PHI and the 400-Tool Dependency Graph
- Per-Sandbox Disk I/O Throttling and the Neighbour You Cannot See
- Patching the Host Kernel Under Running MicroVMs
- Server-Side Rendering Someone Else's React Component
- One MicroVM per Crawl Job: Isolating a Multi-Tenant Crawler
- Letting Customers Run Their Own Container Image
- Workload Identity for MicroVMs That Live 90 Seconds
- How a Control Plane Authenticates Its Host Fleet: Node Tokens, Rotation, and mTLS
- Customer-Authored Policy Code: Rego, CEL, and When a Rules Engine Needs a VM
- Firecracker vs FreeBSD Jails: Two Honest Answers to the Same Question
- Audit Trails When the Machine Is Gone in 200 Milliseconds
- Running MATLAB and Octave Workloads in Isolated microVMs
- Self-Hosting a Compiler Explorer: Running Strangers' Compilers Safely
- Optimisation Solver as a Service: Isolating Jobs That Run for Hours
- Mutation Testing at Scale: Thousands of Broken Builds on Purpose
- Your Dependency Bot Runs Strangers' Install Scripts
- Extracting Untrusted Archives: Zip Bombs, Zip Slip, Symlink Escape
- A Regex Is Untrusted Code That Does Not Look Like Code
- What FedRAMP Asks of a Platform That Runs Untrusted Code
- Private npm and PyPI Mirrors in Front of a Sandbox Fleet
- Answering a Security Questionnaire When You Run Customer Code
- Multi-Tenant WordPress Hosting on Firecracker MicroVMs
- Giving a MicroVM Access to a Customer's Private Network
- Running EDA and Chip-Design Workloads in MicroVMs
- CircleCI Self-Hosted Runners on MicroVMs
- Rowhammer and the Attacks Below Your Hypervisor
- Knowing Which Customer Costs You Money
- Rate-Limiting the Network on a Per-Sandbox Basis
- Spectre, Meltdown, and What a microVM Actually Protects You From
- Immutable microVM Rootfs with dm-verity
- Saying No Correctly: Admission Control for Sandbox Fleets
- The Best Multi-Tenant Isolation Platforms in 2026
- Running Customer Trading Strategies in Isolated microVMs
- Isolating Customer-Managed Key Operations in microVMs
- How to add human approval to agent code execution
- The best AI agent guardrail tools in 2026, by layer
- How to sandbox code from Cline and Continue
- How many sandboxes should a multi-agent system have?
- What is a deep research agent?
- Agent tool permissions, explained
- How to run a RAG pipeline in an ephemeral sandbox
- How to Sandbox Aider's Command Execution
- The best ways to host OpenHands in 2026
- Sandboxing IDE Agent Extensions
- How to Sandbox a browser-use Agent
- The Best Open-Source Coding Agents in 2026 — and What Each One Needs From the Machine It Runs On
- What is the Model Context Protocol (MCP)?
- Tekton Steps, MicroVM Bodies: Isolating Untrusted Tasks
- The best ways to host MLflow in 2026
- Conntrack Table Limits: The Shared Resource Under Your MicroVM Fleet
- Hyper-Threading and microVM Isolation: the SMT Decision
- Ephemeral Databases for AI Agents
- ffmpeg Command Injection: The Filename Is Input Too
- Buildkite Agents on MicroVMs: One Job, One Machine
- Building Container Images for Untrusted Repos Without Privileged Docker
- BuildKit vs Kaniko vs microVMs for Untrusted Image Builds
- Per-Tenant SQLite: One File, One microVM, and No Noisy Neighbours
- Ephemeral Jenkins Agents on Firecracker MicroVMs
- GPU Passthrough and microVMs: The Honest Answer
- SOC 2 for a Platform That Runs Other People's Code
- Running Code Over PHI Without Expanding Your HIPAA Blast Radius
- Compiling User-Submitted LaTeX Without Handing Over a Shell
- A Spreadsheet Is a Programming Language Your Users Don't Call One
- Running Customer Git Hooks in Isolated microVMs
- What is tool calling for AI agents?
- One microVM Per Claim: Isolating Insurance Claims Processing Per Carrier
- Per-Tenant Isolation for CRM Data Enrichment
- Per-Tenant Queue Consumers in Isolated microVMs
- Running Jobs With Customer-Supplied Cloud Credentials
- Designing Quotas That Don't Wreck Your Users
- What Free-Tier Abuse Actually Looks Like
- How to set up team access: orgs, roles and API keys without locking yourself out
- Rendering user-authored templates safely: SSTI and the microVM fix
- The Custom Code Step: Isolating User Code in a Low-Code Builder
- How to build a multi-tenant audit log your customers' auditors will accept
- Docker-in-Docker vs microVMs for CI builds
- A Model File Is a Program: Per-Tenant Serving Isolation
- Your Tenant Wrote a Regex. The Regex Is the Malware.
- Your Support Agent Has a Shell and Your Admin Token
- PID namespaces and process isolation, explained: what CLONE_NEWPID actually gives you
- Container Escape CVEs, by Class: What the Pattern Tells You
- How to Vet a Code Execution Vendor's Security
- Synthetic Monitoring Is a Hostile Workload: One microVM Per Check
- Your API Mock Is a Server Running Customer Code
- CREATE EXTENSION Is dlopen: Sandboxing Untrusted Postgres Extensions
- Data Residency for Sandboxes: Every Byte, Including RAM
- The best Turso alternatives in 2026
- Running a 2009 app in 2026: legacy workloads in microVMs
- On-prem without regrets: shipping your product as a microVM
- One microVM per DSAR: exporting a person's data without leaking someone else's
- eBPF for sandbox observability: what it can and cannot see
- PandaStack vs Azure Container Apps: an honest head-to-head
- How to Receive Webhooks for Deploys and Quota Events
- One microVM per Terraform run: isolating IaC per tenant
- One microVM Per Sync Run: Isolating SCIM Connectors
- Your Free Tier Is a Mining Pool: Stopping Cryptomining Abuse
- Mount namespaces and pivot_root, explained for sandboxing: how filesystem isolation really works
- Every Listing Is a Stranger's Agent: Isolating a Marketplace
- Hostile and Precious: Per-Case microVMs for Forensics and E-Discovery
- One Demo per Prospect: Sales Environments You Can Throw Away
- Run the PoC: Vulnerability Triage in Disposable microVMs
- How to handle file uploads in a deployed app
- A Checkpoint Is a Program: Isolating Untrusted Model Weights
- Running Per-Tenant Blockchain RPC Nodes in MicroVMs
- Per-Room WebRTC Media Servers in MicroVMs
- Guest kernel lockdown and module loading in Firecracker microVMs
- IPv6 for Firecracker MicroVM Fleets
- From Prompt Injection to RCE: The Agent Tool-Call Attack Chain
- node:vm Is Not a Sandbox (And Neither Was vm2)
- Shrinking PCI DSS Scope With Per-Transaction microVMs
- Honeypots on microVMs: a machine you expect to lose
- Customer-Authored dbt Runs, One microVM Per Tenant
- KSM Memory Deduplication for MicroVMs — And Why It's a Trap
- How to manage environment variables and secrets
- Fork-PR CI Without Getting Pwned: One microVM Per Job
- Per-Tenant Static Site Builds in microVMs
- Confidential computing for microVMs: SEV-SNP, TDX, and arm CCA explained
- Linux capabilities, explained for sandboxing: five sets, one bounding ceiling, and the bits that are still root
- io_uring and sandbox security: the fast path that walks around your syscall filter
- Building a data clean room on microVMs
- Hermetic Builds and SLSA Provenance on MicroVMs
- Per-Partner Isolation for B2B EDI and File Integrations
- Firecracker Guest DNS Resolution Explained
- AppArmor vs SELinux for sandboxing: what mandatory access control actually buys you
- Running live technical interviews on microVMs
- Sandbox Mode for Your API: Give Every Customer a microVM
- Rendering Untrusted Ad Creatives in Per-Tenant MicroVMs
- Vercel Sandbox vs E2B for AI-Generated Code
- Side-channel attacks in multi-tenant compute, explained
- Running AI Bookkeeping Agents in Per-Tenant MicroVMs
- Isolating PII Redaction Pipelines in MicroVMs
- Sandboxing SBOM and Vulnerability Scans of Untrusted Artifacts
- Keeping a browser logged in without storing passwords
- Per-Tenant MicroVM Isolation for Thumbnail Generation
- MicroVM Isolation for AI Invoice OCR and Extraction
- Isolating AI Translation Agents on microVMs
- Running dotnet restore and dotnet build on untrusted code in a microVM
- Running bundle install on untrusted Ruby code in a microVM
- Custom domains and automatic TLS, done properly
- Running managed Postgres inside a microVM
- Rotating database credentials without downtime
- Sandboxing an AI Agent That Operates Your Kubernetes Clusters
- User namespaces, explained for sandboxing: what root-in-a-namespace actually buys you
- Detonating malware in Firecracker microVMs
- Sandboxing untrusted uploads: ImageMagick, ffmpeg, LibreOffice
- Running CTF challenges and cyber ranges on microVMs
- Firecracker vs Firejail: confining apps vs containing strangers
- Best Remote Browser Isolation Platforms (2026)
- cgroups v2 Explained for Sandboxing Untrusted Code
- Letting an AI Agent Run Integration Tests Against Real APIs
- Running User-Generated Game Mods in Isolated microVMs
- Per-Tenant Workflow Workers in Isolated microVMs
- Robotics Simulation and RL Rollouts in Isolated microVMs
- Isolating Per-Tenant Geospatial Processing Jobs in MicroVMs
- Processing PHI in Per-Job microVMs: Isolation for Regulated Healthcare Data
- Landlock explained: unprivileged filesystem sandboxing in the Linux kernel, and where it stops
- The Best Ephemeral CI Runner Platforms in 2026
- Running Fuzzing Harnesses and Crash Reproduction in MicroVMs
- Isolating Per-Tenant CSV and Bulk Import Pipelines in MicroVMs
- Isolating Smart Contract Simulation and Forked-Chain Testing in MicroVMs
- What's Actually Inside a Firecracker Snapshot
- Firecracker vs AWS Nitro Enclaves: Two Different Threat Models
- Per-Tenant AI Voice Transcription in MicroVMs
- Running Per-Tenant Billing and Usage Metering in MicroVMs
- Testing Browser Extensions with AI Agents in MicroVMs
- How to Sandbox an Untrusted composer install
- Firecracker vs Amazon ECS Anywhere: Two Different Questions
- Sandboxing User-Written Webhook Transformations
- Firecracker vs Bottlerocket: One Is a Hypervisor, One Is a Host OS
- Per-Tenant Backup and Restore, Isolated by a MicroVM
- Per-Tenant Isolation for AI Training-Data Labeling Pipelines
- The Snapshot Clone Randomness Problem
- Isolating AI Agents That Publish Packages
- Per-Tenant MicroVM Isolation for PDF and Invoice Generation
- Per-Tenant Isolation for Vector Embedding Jobs
- Per-Tenant Feature-Flag Evaluation in microVMs
- Sandboxing AI-Agent Spreadsheet Automation
- Isolating Multi-Tenant GenAI Image Jobs in MicroVMs
- Firecracker's seccomp-BPF filters explained: locking down the VMM's own syscalls
- Best Secure Sandboxes for LLM Agents in 2026
- A Production Checklist for Running Untrusted Code Safely
- Give Your AI Agent a Terminal — Not Yours
- Per-Tenant Isolation for User-Defined GraphQL Resolvers
- Firecracker vs nsjail: which for running untrusted code?
- Firecracker vs Bubblewrap: sandboxing untrusted code
- Per-Tenant ML Inference Isolation With MicroVMs
- Sandbox Your Agent's Computer-Vision Pipeline in MicroVMs
- Per-Tenant ETL Pipeline Isolation With MicroVMs
- Why Firecracker Uses virtio-MMIO, Not virtio-PCI
- How Network Namespaces Isolate Each Firecracker MicroVM
- Build a Headless Browser Screenshot Service on MicroVMs
- Per-Tenant Log Parsing Isolation on microVMs
- Run Code-Migration Agents in MicroVMs, Not on Your CI Box
- Firecracker vs Cloudflare Containers: which model?
- Isolating CI Build Caches Per-Job with MicroVMs
- Sandbox ffmpeg: Per-Job microVMs for Transcoding
- Per-Tenant Search Indexing in Isolated microVMs
- Sandboxing an untrusted Java/Maven (and Gradle) build
- How Firecracker uses the Linux KVM API: an internals explainer
- Best Sandboxes for Running MCP Servers (2026)
- How to Sandbox AI Agents in 2026
- Per-Tenant LLM Fine-Tuning Jobs in Isolated microVMs
- Sandboxing PDF & Document Processing for AI Agents
- Per-Tenant Scheduled Report Generation in microVMs
- The Firecracker VMGenID Device, Explained
- Firecracker Networking: TAP vs macvtap (and netns)
- Building untrusted Rust code in a microVM
- A Zero-Trust Architecture for Executing Untrusted Code
- Per-Tenant Object Storage Isolation with microVMs
- Isolating an AI Slack Bot's Tool Execution in MicroVMs
- Sandboxing an AI Agent's Generated SQL in MicroVMs
- Firecracker vs Nabla Containers: two ways to cut kernel risk
- What Is an AI Agent Sandbox?
- Why Every AI Agent Needs a Sandbox
- Sandbox Your AI Agent's Dependency Audit
- Isolating Genomics Pipelines in Per-Job microVMs
- Per-Tenant Fraud Rules in Isolated microVMs
- Firecracker virtio-rng and Guest Entropy Explained
- Firecracker vs unikernels: two ways to shrink a VM
- Isolating an AI Code-Review Bot That Runs Untrusted PR Code
- Building an autograder that runs student code safely in microVMs
- Per-Tenant Webhook Signing Secrets in microVMs
- Building untrusted Go code in a microVM
- Per-Tenant Analytics Queries in Isolated microVMs
- Isolating AI Shopping Agents in MicroVMs
- Running npm install on untrusted code in a microVM
- Firecracker Doesn't Use vhost-net (On Purpose)
- Per-Match Game Server Isolation on MicroVMs
- Best Secure Code Execution APIs in 2026
- Sandboxing AI-Generated Terraform and Infrastructure-as-Code
- Per-Tenant Email Sending Isolation with microVMs
- Running Customer UDFs Safely in a SaaS with microVMs
- Building an Online Judge on microVMs
- Multi-Tenant Notebooks: microVM Sandboxes vs JupyterHub
- Sandboxing an AI Email-Triage Agent
- Running User-Uploaded Automation Scripts Safely
- Per-Tenant Isolation for RAG and Vector Search
- WASM vs gVisor vs microVM for Untrusted Code
- Isolating Real-Time AI Voice Agents Per Call
- Building a Minimal Firecracker Guest Kernel
- Per-Customer Cron Jobs with microVM Isolation
- Running LLM-Generated SQL and Analysis Safely
- Firecracker's Rate Limiter, Explained
- Kata Containers vs gVisor: the two secure-container runtimes
- Isolating Quant Backtesting Workloads in MicroVMs
- Firecracker vs Cloudflare Workers: which isolation model?
- How gVisor intercepts syscalls: the Sentry, the Gofer, and platforms explained
- Running AI Pentest Agents in Disposable MicroVMs
- The Security Gotchas of Firecracker Snapshots (Secrets Frozen in RAM)
- How to Run AI-Generated Code Safely: a 2026 Playbook
- Protecting CI Secrets from Malicious Dependencies with MicroVM Isolation
- Self-Hosted GitHub Actions Runners in Firecracker MicroVMs
- Per-User Notebook Kernels: Isolating a Hosted Jupyter Product
- Giving Every Agent in a Swarm Its Own Sandbox
- Running a Plugin Marketplace Without Getting Owned
- Firecracker MMDS: Passing Config Into a MicroVM Safely
- VM escape attacks explained: what they are and why microVMs shrink the target
- Best MicroVM Platforms in 2026: An Honest Buyer's Guide
- How to Build a Remote Code Execution API Safely
- Give Your AI Coding Agent a Sandbox to Run PR Checks
- A MicroVM for Every LLM Tool Call: Per-Request Isolation
- Firecracker vs Kata vs gVisor: three isolation models
- PandaStack vs Blaxel: agent sandbox platforms compared
- The Firecracker security model: how a microVM actually contains untrusted code
- Running MCP Tools Safely: Sandbox the Execution
- WebAssembly vs Firecracker for Untrusted Code
- Isolating Batch Jobs and Queue Workers with MicroVMs
- Give an AI Coding Agent a Real Git Workflow in a Sandbox
- Isolating Untrusted Webhook Handlers in MicroVMs
- Safely running pip install from LLM-generated code
- Isolating Tenants in a Multi-Tenant SaaS with microVMs
- A Sandbox for AI Agent Computer Use
- The Firecracker Jailer Explained
- PandaStack vs gVisor: choosing your isolation boundary
- How Firecracker's virtio Devices Work
- Controlling Network Egress for Untrusted Code
- Isolating CI/CD Build Steps in MicroVMs
- How to Sandbox Untrusted Jupyter Notebooks Per User
- seccomp explained for developers: filtering syscalls to shrink the kernel attack surface
- How to Jail LLM-Generated Code
- Run Untrusted MCP Servers in Isolated MicroVMs
- Kata Containers vs Firecracker: Honest Head-to-Head
- Best Firecracker Alternatives in 2026
- Safely Running Shell Commands an AI Agent Decides to Execute
- MicroVM Density: The Economics of Per-Tenant Isolation
- KVM explained for developers: the hardware boundary under microVMs
- Firecracker Use Cases: Who Runs MicroVMs and Why
- Database-per-Tenant Isolation with MicroVMs
- Browser Isolation in MicroVMs: Headless & Remote
- Sandboxing LLM Tool Calls and MCP Servers
- MicroVM vs VM vs Container: A 2026 Comparison
- gVisor vs Firecracker: Which Isolation for Agents?
- Self-Hosted Code Execution Sandbox for Production AI
- WebAssembly vs MicroVMs for Sandboxed Code
- Stop an AI Agent Touching the Host Filesystem & Network
- How to Sandbox Untrusted & AI-Generated Code
- Why Docker Isn't a Sandbox
- The Code Isolation Hierarchy
- Multi-Tenant Code Execution: Isolation Requirements
- What is a microVM? Firecracker, isolation, and why agents need it
- How to run untrusted (and AI-generated) code safely
- Secure code execution for AI agents: isolation, ephemerality, and network control
- PandaStack vs Daytona for AI Sandboxes