OSS + ELC EU 2026

Your AI agent is Dory. Every conversation it wakes up unable to remember a thing , so you, Marlin, re-explain everything every turn. Four open-source memory systems promise to fix that: Cognee, MemOS, Honcho, and MemPalace. But which architecture actually pays off in tokens, dollars, and resolved tasks?
This talk runs two experiments. First, we benchmark all four backends head-to-head on a single Kubernetes substrate , same harness, same workloads, same OpenTelemetry Collector and rank them by token efficiency, cost per resolved task, and recall under contradiction.
Then we test the question most teams haven't asked: is running an agent with memory worth it at all? We measure two real OSS agent frameworks , kagent (CNCF Sandbox) and sympozium with their built-in memory turned on, then turned off. Real workloads, real numbers.
None of the four backends ships first-party OTel today; the Helm chart, OTel pipeline, and upstream PRs are how we close that gap for the ecosystem.

Imagine asking an AI agent to analyze any data, only for it to hallucinate a schema that doesn't exist. This "context gap" is the primary barrier to reliable Data-Aware AI. While LLMs are brilliant reasoners, they are historically "blind" to the live, structured world of Postgres - until now!

In this talk, we will explore how the Model Context Protocol (MCP) bridges this gap, transforming Postgres from a passive storage layer into an active reasoning engine. We’ll dive into the architecture of a Postgres MCP server, demonstrating how it provides agents with secure, structured access to schemas and metadata. By utilizing tools like pg_catalog and EXPLAIN, we enable LLMs to understand table relationships and optimize performance before running queries.

Expect live demos and practical insights on making Postgres "talk" to AI safely and effectively.

Key Takeaways:

* How Postgres + MCP provides LLMs with correct, real-time database context.
* Leveraging Postgres metadata and schema to eliminate SQL hallucinationcs.
* Implementing secure, multi-tenant, and read-only access for AI agents.
* Enabling AI agents to use EXPLAIN and other tools for self-optimization.

Machine learning is increasingly used in high-energy physics, particularly in trigger systems that process data at rates of 100 kHz while making real-time event selection decisions. The latency and reliability requirements demand highly optimized inference pipelines. While portable solutions such as ONNX Runtime simplify deployment, many applications rely on hardware-specific libraries like NVIDIA TensorRT and MIGraphX (via ROCm) for optimal performance. Code-generation approaches such as SOFIE offer additional efficiency but introduce integration complexity.

We present a unified inference interface that abstracts backend-specific details while preserving performance. It enables execution across multiple inference libraries without data copies or user-side configuration changes. An offline processor converts trained models into backend-optimized plans, and a lightweight runtime loads and executes them through a common API with direct data access for heterogeneous environments.

AI agents are moving from chat interfaces into workflows that read files, call tools, modify state, and coordinate multiple services. In cloud-hosted designs, this often creates a fragile trust boundary: private data leaves the device, tools are authorized through broad API keys, and the user has limited visibility into what the agent can do. This talk presents an open-source, local-first architecture for permissioned AI agents that can operate offline on Linux edge or personal infrastructure. We will break down the architecture into model serving, retrieval, tool invocation, capability scoping, identity, audit logs, sandboxing, human approval, and fallback synchronization when connectivity returns. The session is not about a specific agent framework; it is about the system boundary around agents. Attendees will learn how to separate reasoning from action, how to map tools to least-privilege permissions, how to keep sensitive context local, and how to evaluate agent workflows when network access is unavailable or intentionally disabled.

Software’s environmental footprint, especially AI’s, is becoming a business, governance, and regulatory priority. The EU AI Act introduces environmental transparency expectations for general-purpose AI, while the CSRD expands sustainability reporting obligations to 50,000+ companies. As software and AI adoption accelerate, organizations are increasingly seeking consistent ways to measure carbon, energy, and water impacts across workloads and inference.

The Green Software Foundation, a Linux Foundation project, is helping shape the open standards foundation for this transition:

• SCI (ISO/IEC 21031:2024): the ISO-ratified standard for software carbon intensity
• SEE: measuring software energy efficiency across workloads
• SCI for AI: extending measurement to AI training, fine-tuning, and inference
• SWE: addressing the growing water footprint of software and AI systems

Drawing on direct experience chairing and co-leading these specifications, this session explores how these standards connect, align with emerging expectations such as the EU AI Act and CSRD, and help organizations build measurable, transparent, and sustainable software and AI systems.

As AI workloads move into production in cloud native environments, the open source community must define the future of AI inference infrastructure. This panel convenes experts from leading projects to assess the ecosystem and chart a path forward.

Key themes include:

- The evolution of cloud native inference (from serverless to large‑scale distributed serving)
- Performance and efficiency advances such as KV cache management, quantization and hardware acceleration
- The need for standardization across APIs, model formats and interoperability.

They’ll also examine how projects like vLLM, llm‑d, and KServe can collaborate to reduce fragmentation.

Panelists will address real‑world challenges in Kubernetes deployment, including multi‑tenancy, GPU sharing, autoscaling and observability. There will also explore emerging trends such as edge inference, multi‑modal models and the convergence of training and inference systems.