Open Source Summit + Embedded Linux Conference North America 2026

Many models referred to as "open source" are distributed under restrictive licenses and fail to include the necessary information to actually qualify as open source. Just because a model is on HuggingFace does not mean it is open source.

Several attempts have been made to provide a definition of what "open source AI" ought to be but we now have a tool that can help: the Model Openness Tool (MOT).

The MOT was developed by the Generative AI Commons as an implementation of the Model Openness Framework (MOF) to provide model producers and consumers with a practical way to assess how open a model really is. This session will introduce attendees to the MOT and include a demo showing how it can be used along with Hugging Face and GitHub to provide greater understanding of which models are really open.

You have built your first MCP server and tested it with the MCP inspector, but it only uses stdio or streamable HTTP without HTTPS. Do you rewrite your server to add authentication and authorization, or is there a smarter way? What if you have multiple MCP servers? Can you unify them under a single virtual server without touching any of the originals? How do you deploy all of this to Kubernetes securely and reliably?

In this demo-driven session, Lin takes you from building a simple MCP server and securing it the hard way. Then she offloads authentication, authorization, and tool multiplexing to an MCP gateway. She will show how to deploy a virtual MCP server in Kubernetes and program an AI agent to call its tools, making complex setups feel effortless. By the end, you will have practical techniques to run, secure, and scale your MCP servers with confidence.

Planning a trip is a deceptively complex problem for AI, especially when the journey starts from visual context rather than text. In this session, we present a multimodal-first, local-first agentic architecture where a user uploads an image (e.g. “where is this place?”), and the system builds a travel plan from that visual input using Model Context Protocol (MCP), A2A (Agent-to-Agent), and BeeAI — all running fully locally without cloud dependencies.

The system employs a router and specialist agent pattern, where dedicated agents handle image understanding, hotel search, and flight search, each backed by MCP servers. A multimodal model extracts meaning from the image, after which the router decomposes the task and delegates work through A2A to the appropriate specialists.

We will walk-through how BeeAI manages agent lifecycles, how A2A enables explicit agent collaboration, and how MCP acts as a stable contract layer between reasoning and real-world capabilities. The focus is on practical architecture, configuration, and lessons learned, showing how to build MCP-centric, multimodal systems that remain extensible, reproducible, and maintainable as new agents and tools are added.

There's something strange in your infrastructure. Who you gonna call?
OpenClaw , the open source AI agent formerly known as Clawdbot, then Moltbot exploded past 150,000 GitHub stars in weeks. It connects LLMs to your messaging platforms, terminal, and file system, giving AI full autonomous control. But like a Ghostbusters ghost, it wreaks havoc: $20 in tokens burned overnight to check the time, a one-click RCE (CVE-2026-25253), 21,000 exposed instances, and 341 malicious skills in the marketplace.
I will straps on my proton pack to bust these ghosts with open source tools. First, the OpenClaw Observability Plugin :
- an OpenTelemetry-based plugin capturing full agent lifecycle traces: request → agent turn → tool calls, with per-tool timing, token breakdowns, and error tracking. Your PKE meter for rogue AI.
- Then, Tetragon , eBPF-powered kernel-level policies restricting file access, network connections, and process execution. The containment unit no prompt injection can escape. A live demo ties it all together: OpenClaw + observability plugin + Tetragon, with traces and security events flowing into one dashboard.
We came, we saw, we traced it.

LMCache supports tiered KV caching with CPU memory offloading, extending inference beyond GPU memory limits. But what happens when local CPU memory isn't enough? This session introduces the next tier: offloading KV cache to Amazon SageMaker HyperPod managed storage, expanding cache capacity for large-scale LLM inference.

We'll cover the technical design of the SageMaker HyperPod connector contribution to LMCache. Hot entries stay in GPU memory, warm entries spill to CPU memory, and cold entries persist to HyperPod's managed storage. This three-tier architecture lets organizations cache far more context than local resources allow, reducing redundant computation for repeated prompts and long-context scenarios.

The session demonstrates the integration in action, showing cache hit rates, latency across tiers, and how the connector handles transitions between local and remote storage. We'll discuss key engineering decisions, including async prefetching and failure handling.

Attendees will leave with practical knowledge of how managed cloud storage can extend open source caching frameworks for LLM inference infrastructure.

Modern platform engineering has a 'context' problem. As infrastructure scales across Kubernetes, hybrid clouds, and internal developer platforms (IDPs) like Backstage, traditional RAG systems struggle to answer multi-hop queries like 'Which services depend on this failing database?' or 'What is the blast radius of this IAM change?'
In this session, we explore how GraphRAG—a combination of Knowledge Graphs and LLMs—solves the reasoning gap that vector-only search leaves behind. We will demonstrate how to index infrastructure as a graph of entities and relationships, allowing AI agents to perform complex root-cause analysis and automate documentation. Attendees will leave with a blueprint for building an open-source GraphRAG pipeline to turn platform data into actionable intelligence."

AI systems need more than intelligence; they need context that persists. Without it, even strong models can misinterpret information, lose decision rationale, or repeat the same mistakes. Context Graphs have emerged as a practical pattern for agentic AI: a living graph that captures not only what was retrieved or known, but how context led to actions through tool calls, constraints, policies, and outcomes, stitched across entities and time so precedent becomes searchable.

This talk explores context engineering as the discipline of designing that context layer, and shows how context graphs complement retrieval by enabling multi-hop, structured context assembly (building on GraphRAG-style hierarchical summaries) while improving explainability and evaluation. Attendees will leave with a practical understanding of how to build context pipelines that combine contextual retrieval with persistent memory and provenance, and why context graphs are becoming central to trustworthy, enterprise-ready AI systems.

Model Context Protocol (MCP) is quickly becoming a foundational interface for agent–tool interaction, but most implementations today stop at simple, single-server tool exposure. This session explores practical MCP design patterns that move beyond “one server, one agent” toward scalable, interoperable, and ecosystem-friendly architectures.

Based on real-world experimentation and open-source implementations, we will walk through a set of MCP patterns, including:
1. Single MCP Server patterns for tool and data exposure
2. Multi-Server composition and routing patterns
3. MCP Host / Gateway patterns for aggregation and policy control
4. Plugin-style extension patterns that allow third-party MCP servers to integrate without code changes
5. Read vs. write MCP patterns for observability, automation, and feedback loops

The talk focuses on when and why to apply each pattern, common pitfalls, and architectural trade-offs. Attendees will leave with a mental model for designing MCP-based systems that scale from local experiments to ecosystem-level platforms, enabling agents, tools, and platforms to evolve independently while remaining interoperable.

As LLMs shift from chatbots to autonomous agents, the limits of "single-shot" RAG are surfacing. Static retrieval often introduces irrelevant context that misleads models. To solve this, developers are adopting Corrective (CRAG) and Adaptive RAG, requiring databases to act as active reasoning runtimes rather than simple stores.

This session explores building self-correcting AI agents using an open-source relational stack. We will demonstrate how to bridge the gap between semantic search and structured data using the Model Context Protocol (MCP) and native MariaDB vector indexing.

Technical topics include:

The Critic Loop: Implementing self-correcting architectures that validate retrieved documents before LLM synthesis.

Hybrid Querying: Combining vector indexing with relational SQL in single ACID transactions to reduce agentic loop latency.

Standardizing Communication: Using the MariaDB MCP Server for secure, tool-based access to live data.

Scaling State: Managing concurrent agent sessions without sacrificing data integrity.

Attendees will leave with a blueprint for building reliable, autonomous systems using open-source database patterns that move beyond basic vector search.

Every enterprise has identity management for humans—SSO, MFA, RBAC, audit logs. But AI agents? They run with API keys, no verified identity, no behavioral tracking, no audit trail.

This talk bridges the gap between traditional IAM and the emerging world of autonomous AI agents:

What we learned from human IAM:

- Why identity must be cryptographic, not just credentials

- How least-privilege access control prevents lateral movement

- Why audit trails matter for compliance and incident response

Applying it to AI agents:

- Agent identity: Ed25519 keypairs vs API keys

- Capability-based access: what tools can this agent call?

- Behavioral trust scoring: detecting compromised agents

- MCP server attestation: verifying the tools agents connect to

We'll examine real attack scenarios—agent impersonation, tool injection, privilege escalation—and show how identity-first security prevents them.

Live demo using AIM (Agent Identity Management), an Apache-2.0 open-source platform. All patterns are framework-agnostic and applicable to LangChain, CrewAI, AutoGen, or raw MCP implementations.

Attendees leave with actionable security patterns for their AI agent deployments.

LLM tokens are expensive. With context windows expanding to 200K+ tokens, a single API call can cost several dollars & in production systems handling thousands of requests, these costs compound quickly.
Most optimization efforts focus on model selection or prompt engineering, but the context itself often contains massive redundancy.

Headroom is an open-source Python library (https://github.com/chopratejas/headroom) that sits between your application and your LLM provider, transparently optimizing context before it reaches the model.
The core insight is simple: LLM contexts—especially in agentic workflows—are filled with repetitive tool outputs, verbose JSON arrays, and boilerplate that consumes tokens without adding proportional value

Headroom introduces novel concepts such as reversible compression, cache aligners, compression routers, and even persistent memory

Real-world results:
- 50-90% token reduction on typical agentic workloads
- Drop-in integrations for LangChain, OpenAI, Anthropic, and any OpenAI-compatible provider
- Zero code changes required when using the proxy server

We optimize LLM inference around compute—faster kernels, better batching, smarter parallelism. But in production, the real bottleneck is state. The KV‑cache holds precomputed attention data that turns a multi‑second prefill into a sub‑second cache hit. Lose it to eviction, isolate it on one node, or route away from it, and you pay the full compute cost again for work you already did.

llm-d is an open-source distributed inference platform, co-founded by Google, IBM Research, Red Hat, NVIDIA, and CoreWeave, that treats the KV‑cache as the core of the system rather than a byproduct. That enables tiered memory management—offloading KV blocks from GPU to CPU to shared storage—cross‑replica reuse so cached state computed anywhere is usable everywhere, and cache‑aware scheduling that routes requests to the replica most likely to hold their prefix.

This session walks through how llm-d and vLLM implement each layer of this stack, how they combine into a production system, and what the open‑source community can build on top. We’ll share benchmarks, Kubernetes deployment patterns, and practical guidance for operators running LLM workloads at scale.