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 security320 posts
Running a DICOM Pipeline in a MicroVM: Untrusted Medical Images, One Study at a Time
A DICOM file tells your process which several thousand lines of C to run next, and hospital archives are full of objects written by a decade of vendor encoders — so malformed is the normal case, not the attack case. Here is the per-study microVM shape that makes a crashing codec one deleted machine instead of a disclosure question.
Per-Tenant Map Tile Rendering in MicroVMs: When Your Customers Write the Stylesheet
A map style is not configuration, it is a program: a few kilobytes of JSON that tells thirty years of C++ how much memory to allocate and which files to open. Here is what happens when one tenant writes a bad one, and the per-tenant microVM shape that keeps it their problem instead of everybody's.
Per-Tenant Payroll and Tax Engines in microVMs: Determinism Is the Product
A payroll or tax engine is a pure function on paper and a function of fifteen undeclared arguments in production: tzdata, ICU, glibc, a rounding mode nobody chose, and the customer's own deduction formula. Then an amended return arrives three years later and asks for the same number, plus an explanation.
A Font Is a Program: Rendering User-Uploaded Typefaces Without Trusting Them
The moment you accept a .ttf from a user, you have accepted a program: TrueType carries a stack machine, CFF carries another one, and woff2 puts a Brotli decoder in front of both. Here is why that parser should not run in the process holding your database credentials, and the microVM shape that fixes it.
Compiling a Stranger's Shader: Isolate the Toolchain, Because You Cannot Isolate a GPU You Do Not Have
If your product accepts shader source from users or from a model, you are running a pile of C++ parsers on hostile input. PandaStack has no GPU and cannot run your shader on one — but glslang, spirv-val, spirv-opt and spirv-cross are all CPU work, and that is the part that actually hurts you.
Analysing APKs Nobody on Your Team Wrote: One MicroVM Per Sample
The thing that breaks your mobile-app scanning pipeline is not a shell. It is a jadx run that pins every core on one crafted DEX, an apktool that writes small files until the volume runs out of inodes, and a zip entry named ../../etc/cron.d/x. Here is the isolation shape that survives that, and what it still cannot do.
PandaStack vs Kubernetes Jobs: Where "Just Create a Job" Stops Being the Right Answer
Your first instinct is to create a Kubernetes Job, and that instinct is usually correct. Here is the hardened Job you should actually write, the four mechanisms where the model breaks for untrusted per-request code, and the shim you will own if you push through anyway.
Firecracker vs Hyper-V Isolated Containers: Two Ecosystems, One Verdict
Microsoft shipped Hyper-V isolated containers because Windows containers on a shared kernel were not a boundary they would stand behind for other people's code. The Linux world shipped Firecracker, Kata and gVisor for exactly the same reason. Same verdict, opposite engineering — and one of them cannot run your Windows binary.
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.
More posts in this topic
- Encryption at Rest for Sandbox Disks and Snapshots
- Pickle Is a Virtual Machine You Have Been Downloading
- Giving an AI Agent a Language Server: The Index Is Code Execution
- Where to Run devcontainer.json in 2026
- Top 10 Throwaway psql Platforms for Engineers (2026)
- Parsing Untrusted XML: The Format That Ships an Interpreter
- Per-Tenant Audio and DSP Rendering in MicroVMs: The Plugin Is the Payload
- Running a Multi-Tenant Render Farm on MicroVMs: A .blend File Is a Program
- 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