Open Source Summit + Embedded Linux Conference North America 2026

Caching has traditionally relied on exact matches: the same input produces the same cached output. AI systems challenge this assumption by introducing semantic similarity — requests that are different on the surface but equivalent in meaning. This talk explores how caching is evolving to support AI workloads, from classical key-value strategies to semantic caching using vector search. We'll walk through a practical architecture that layers exact and semantic caches in front of an expensive model and demonstrate how hybrid caching can reduce cost and latency. This talk will explore multiple open-source systems, such as OpenSearch and Valkey, and discuss the tradeoffs that they provide and when they matter.

The transition from passive RAG to autonomous agentic workflows forces a dangerous trade-off: to be useful, agents need access; to be safe, they need restrictions. Giving a non-deterministic LLM distinct permissions to your Kubernetes cluster is a security nightmare, yet agentic tool execution demands real-world access to be effective.

This session introduces a battle-tested architecture for Zero Trust Agents. We will demonstrate how to secure Model Context Protocol (MCP) servers within private networks, replacing risky static credentials with a dynamic control plane that enforces strict safety guardrails.

Attendees will learn:

Identity for Autonomy: How to integrate OpenBao (LF Edge) to issue Just-In-Time (JIT) credentials, ensuring agents only hold permissions during active tool use.

Bounding Agency: Implementing "Read/Write Separation" at the protocol level, preventing stochastic errors or misinterpretations from causing deterministic outages.

Secure Orchestration: A blueprint for deploying MCP servers as secure bridges between AI reasoning and internal infrastructure.

Stop building toys. Learn how to deploy autonomous systems that your security team will actually approve.

Server-side WebAssembly applications need filesystem access, but current options are limited. Host filesystem access breaks portability and sandboxing. wasi-vfs is read-only and targets Preview 1. wasi-virt supports Preview 2 but remains read-only and single-application only.
We present a virtual filesystem built on WASI Preview 2 and the Component Model that supports read/write, multi-app sharing, dynamic attachment via RPC, and optional S3 persistence. The stack uses open-source tooling from the Bytecode Alliance: wasmtime, wac, and wit-bindgen.
The talk walks through our architecture: an inode-based in-memory filesystem exposed through custom adapters implementing wasi:filesystem, composed at build time with wac plug. We then separate the filesystem into a standalone server, add RPC for runtime attachment without recompilation, and layer S3 persistence for durability. Each stage is demonstrated live.
We close with lessons learned and tradeoffs between build-time composition and runtime RPC. No deep Wasm expertise is assumed. This talk is for developers building Wasm platforms, those exploring the Component Model, and anyone curious about filesystem virtualization in WebAssembly.

Distributed caches are often used for scenarios that don't actually require them. For massive datasets (100's of GB's or more), distributed caches make sense—the data simply won't fit in a single node's memory. However, distributed caches tend to be overkill when working with smaller data sets (100s of MBs to 10s of GBs) that do fit in memory. Additionally, using traditional In-Memory caching libraries creates additional operational challenges, such as cache stampedes during TTL expiration, memory spikes during reloads, and long cold-start times that directly affect deployment velocity.

This talk proposes an alternate, unconventional view: What if we could decentralize our cache while centralizing its preparation? We'll discuss how dataset distribution using Hollow (an open-source project by Netflix) enables applications to serve data from local memory with microsecond access latency while staying perfectly synchronized via delta-based updates.

We'll cover:
- Design trade-offs that make this pattern ideal for GB-scale, read-heavy workloads.
- Delta-based updates that optimize cache reloads/refreshes.
- Zero-downtime updates applied in milliseconds without memory spikes.