Large time models, or foundation forecasting models, have transformed how forecasting is done. We now have access to large pretrained models capable of zero-shot inference, allowing us to use these models at scale. However, there are still many ways we can improve these models with capabilities that are not native to them. In this talk, we first present how synthetic data can help improve the accuracy of a model. Synthetic data is cheap to create and can overcome the issues of data scarcity or the difficulty of getting more data. Then, we discuss conformal predictions to provide a better quantification of uncertainty. Conformal predictions are a distribution-free and model-agnostic approach to have more representative prediction intervals. We also explore reconciliation techniques for better accuracy. This is especially important in situations where one level must aggregate to another, e.g.; cities to country. Finally, we apply all those concepts in a forecasting agent for a low-code approach.
Unwind after a stimulating day at ODSC with fellow AI and data science enthusiasts! Join us for a casual drinks, happy hours, and dinners. It’s a great opportunity to network in a relaxed setting, share insights, and forge new connections. (self-paid)
Modern AI systems are impressive until you ask them to behave like anything other than a goldfish by asking them to remember what happened five minutes, five days, or five sessions ago. That works for one-off question answering, but it breaks down when agents need to support long-running tasks, adapt to user preferences, recover from past mistakes, or reason across evolving contexts. This session explores Cognitive Memory Architectures as a practical design pattern for moving beyond "stuff everything into the context window and pray," humanity's most computationally expensive filing cabinet.
Grounded by Endel Tulving's distinction between episodic and semantic memory, we will focus on how concepts, like episodic memory, can give RAG and agentic systems durable continuity across interactions. Rather than flattening every conversation into summaries or vector traces, episodic memory preserves the event-level details that matter: what happened, when it happened, why it mattered, and how it should influence future behavior. We will examine how agents can store raw interaction records, consolidate useful memories over time, separate temporary context from durable knowledge, and apply controlled forgetting so memory improves reasoning instead of becoming an ever-growing junk drawer of embeddings.
The workshop will start with a simple RAG Agent and progressively build towards a stateful multi-agent system with durable memory using Python.
As the value of coding agents in practical software engineering becomes firmly established, many assume the logical conclusion is to go fully agentic. This culminates in a vision called the Dark Software Factory - we turn the lights off and never see the code again.
This talk takes the opposite position: Dark Software Factory is flawed as a general recommendation, and being "more agentic" is not always better.
My proposed alternative is The Show-Me Method. You should decide which parts of your application are "code worth writing" and which should be left to agents. Evolve over time in support of your business needs. Consider abstractions other than prompts to gain leverage with lower risk.
The more open-ended an AI system becomes, the harder it is to anticipate how it fails. With agentic AI, the combinations of models, tools, and enterprise data are nearly infinite. You can't enumerate the edge cases. Outliers are your new baseline. Left unmonitored, these systems can cascade errors into costly actions at scale.
Meanwhile, threat actors are already working to hack these very systems and turn them into autonomous insiders, capable of 10x the damage in a fraction of the time.
This session covers the common failure modes of agentic systems and the trust infrastructure you need to spot, monitor, and remediate AI-based risks at machine speed.
As the capabilities of modern LLMs grow, their fields of application also widen. In order to meet the expectations of your customer, a simple RAG application is not sufficient anymore: they expect the chatbots to use tools, to search the web, to self correct, and more. In short, they want an AI Agent.
In this workshop we're going to explore how to take your existing RAG pipeline and, step-by-step, transform it into an agentic system, without throwing away all the work your team has done so far. We will first create a very small RAG application and then upgrade the system, one step at a time, until we have a fully-fledged agent that can take on long running tasks.
This workshop is not tied to any specific framework: we will work from first principles and cover the concepts as well as the implementations, so that you can apply these concepts to your specific infrastructure and tools.
We keep trying to secure AI the same way we secure software, and that assumption is already costing us.
Modern AI systems don't behave like traditional applications. They write code, call tools, chain decisions, and interact with the world with increasing autonomy -- and most organizations are still spending their time trying to control what the model says. That's not where the bodies are buried.
I've spent three years red teaming AI systems across enterprise and government environments, and the same pattern shows up every time. The interesting failures aren't in the model. They emerge in everything built around it.
These systems expose a different kind of attack surface: agents with delegated authority, tool sprawl across environments, workflows that drift from read to action, memory and context that outlast any single session. This talk walks through how those surfaces get exploited.
We'll look at real adversarial scenarios -- a benign prompt that becomes an action chain, a low-privilege interaction that escalates through tool access, an agent that routes around intended controls without touching a traditional vulnerability, ""allowed behavior"" that becomes the attack path.
To make sense of why this keeps happening, I use a simple frame: behavior, authority, and control. The industry is obsessed with behavior. Attackers aren't. They're going after authority and the absence of meaningful control around it.
What that produces is a class of systems that don't need to be broken in order to be exploited. They only need to be used as designed.
Teams are reaching for Kubernetes to run agent sandboxes, and it's the wrong tool. Kubernetes is built to keep things alive and hold them in a steady state. A sandbox is born, forked, and killed before any of that machinery catches up.
The mismatch compounds because the sandbox keeps gaining requirements without shedding any. In eighteen months it went from a fast code-snippet runner, to a stateful box for long-running agents, to ten thousand ephemeral environments that fork for RL rollouts and die in under a second. It has to be all of those at once, a contradiction set no orchestrator was designed to hold.
The cost shows up the moment you measure it. We ran the same 50-action bug-fix trajectory across five stacks and got a 12x spread: 12.9s on the fastest, 161.5s on the slowest. The gap isn't compute, it's lifecycle overhead per action. We name every stack and explain the mechanism behind each number.
This workshop is targeted at the intermediate+ developer wanting to build agentic applications that support MCP. We will discuss what MCP is, what use cases it works well for, and the main components of the MCP ecosystem. Then we will focus in on MCP clients, what they do, how they've changed with the latest protocol release, and how to build them in the new v.2 Python SDK. By the end, participants should be able to build an MCP client that supports the major features of MCP: tools, prompts, and resources.
Enterprises are rapidly moving from generative AI experimentation to a new phase of transformation: agentic AI systems that can reason, take action, and complete multi-step workflows across business tools, data, and teams. Yet many organizations still struggle to convert AI pilots into measurable business value because of fragmented data, siloed systems, limited production know-how, and insufficient governance.
This session will help attendees understand how enterprises can bridge the gap between frontier model capabilities and scalable deployment. We will examine the evolution from conversational AI to reasoning systems and agentic workflows, then explore practical patterns for building agents that operate across enterprise surfaces such as productivity tools, developer environments, browsers, desktops, APIs, and customer-facing products.
Attendees will learn how to identify high-value agentic use cases, design single-agent and multi-agent architectures, ground agents in enterprise context, apply evaluations and guardrails, and deploy agents with appropriate permissions, monitoring, and governance. The session will also cover examples across industries including financial services, telecommunications, retail, healthcare, software engineering, and enterprise operations.
Practitioners will leave with an understanding for moving beyond isolated AI pilots toward governed, reusable, and scalable agentic systems that improve workforce productivity, automate operations, and power AI-native products.
Pricing is where strategy meets science. For businesses building with or on top of AI, pricing decisions made inside frontier labs directly shape their costs, product roadmaps, and competitive position. And for AI companies themselves, pricing is one of the most consequential and least understood strategic levers available.
This session brings an insider perspective from the frontier to practitioners navigating these decisions in real time. Drawing on direct experience in product finance and strategy at Anthropic, where pricing decisions touch everything from token economics to enterprise packaging to model launch strategy, we'll examine what makes AI pricing fundamentally different from every pricing model that came before it, and what that means for the businesses consuming, building on, and competing with frontier AI.
We'll cover what actually drives AI economics, and why token-based consumption models create cost structures that behave nothing like SaaS. We'll look at how frontier labs think about the trade-offs between simplicity and sophistication in pricing design, why complex pricing can be a one-way door in a still-evolving market, and how outcome-based models are beginning to reshape what value means in AI.
Attendees will leave with a practical framework for evaluating AI pricing, concrete tools for making smarter budgeting decisions, and a clearer mental model of the strategic forces shaping how intelligence gets packaged and priced today.
Reasoning models for Physical AI aim to enable embodied agents—such as robots and autonomous vehicles—to perceive, understand, and act in the real world through contextual and causal reasoning. In this talk, I’ll provide an overview of foundational concepts in reasoning-centric AI for physical systems, highlighting the emergence of chain-of-thought reasoning in autonomous driving models such as NVIDIA’s Alpamayo family, which bridges human-like reasoning with trajectory planning to improve handling of complex scenarios. I will discuss model design principles, training strategies that promote causal reasoning, tools and datasets for development and evaluation, and open challenges at the intersection of physical reasoning, safety, and real-world deployment.
Serving a large language model is not like serving a normal ML model. The model writes one word at a time, and every word means re-reading gigabytes of weights and a growing memory cache from the GPU. That is why LLMs feel slow and expensive — and why simply adding more GPUs often makes things worse instead of better.
This hands-on workshop takes you from the ground up. You do not need prior serving experience. We start with the simple ideas that explain everything else: why inference is limited by GPU memory bandwidth, and how to calculate the memory and speed of any model on the back of a napkin.
From there we get practical. On a single GPU (a free Colab or cloud instance is enough), you will make a model faster and cheaper yourself: shrink its memory cache, turn on smart caching and quantization with vLLM and SGLang, and measure the speed-up. Then we scale up. Through guided, pre-built demos you will see how models are split across many GPUs, and how the largest systems separate the "prefill" and "decode" stages across machines using NVIDIA Dynamo and llm-d on Kubernetes.
Whether you are new to LLM serving or already run it in production, you will leave able to size a deployment, cut its cost, and understand exactly how inference scales from one GPU to a cluster. All notebooks and code are open-source on GitHub.
Most of us treat inference engines like a black box: you send a request to your favorite LLM and you get tokens back. This talk walks through every single component of LLM inference.
We'll follow one request end to end, from the HTTP POST to the streamed output tokens, and see what the engine is actually doing at each step. Tokenization and the input pipeline. How the scheduler decides what runs next, and how continuous batching lets a single forward pass serve hundreds of users at once. How chunked prefill keeps one giant prompt from ruining latency for everyone else. How the KV cache is managed like virtual memory with PagedAttention, and how prefix caching quietly saves you work you didn't know you were repeating. Then sampling and detokenization on the way back out.
An inference engine really is just a big machine for keeping the GPU busy by orchestrating every single calculation involved in running a LLM and in this talk we'll cover everything.
Aimed at AI engineers who use these systems and want a real mental model of what's happening underneath. No prior knowledge of engine internals needed.
partial: All verifiable upcoming-edition names on the inspected page were extracted. This is not a claim that the final event roster is complete. Reviewed 2026-09-10T19:50:51.263Z.
sponsors
not extracted: Not yet extracted from an edition-specific public source. Editorial review date unavailable.
exhibitors
not extracted: Not yet extracted from an edition-specific public source. Editorial review date unavailable.
attendees
not extracted: A public named attendee roster has not been extracted. Speakers and company employment do not imply named attendance. Editorial review date unavailable.
agenda
partial: Only the inspected program material is included (partial_session_extraction); full agenda coverage remains incomplete. Reviewed 2026-09-10T21:40:34.942Z.
Sources
Showing 9 of 9 source records. A source check is not a claim of complete extraction.
Organizer markets the location as San Francisco; venue is at San Francisco Airport in Burlingame. Virtual access is offered; individual session coverage depends on the pass.