Open Source Summit India 2026

AI is moving from experimental "chat" to autonomous "agents," but the infrastructure remains the biggest bottleneck. This keynote session highlights how the industry is collaborating on open source projects to build a standardized AI-Native stack. From hardware-aware scheduling to automated deployments and secure isolation, learn how open collaboration is turning complex AI infrastructure into a production-ready utility for the enterprises.

As proprietary models like GPT-5 and Gemini assert dominance in professional domains, the open source community faces a critical challenge: how do we verify their claims without access to their weights? We cannot inspect their code, but we can rigorously audit their reasoning using open source benchmarks.

In this session, 16-year-old researcher Kannan Murugapandian presents a technical evaluation of state-of-the-art LLMs using the LegalBench open dataset.

Moving beyond simple Q&A, this session explores:

1. The Evaluation Harness: A deep dive into the custom Python-based testing asynchronous pipeline designed to standardize prompts, manage vector retrieval, and score outputs across disparate model APIs.
2. Open vs. Closed: A data-driven comparison of how open weights models (e.g., DeepSeek/Llama) stack up against closed giants when tasked with complex legal logic.
3. The "Persona" Myth: Quantitative results testing whether "lawyer personas" actually reduce hallucination rates or merely change the output tone.

Robust guardrails are a foundational requirement for preparing AI agents for enterprise‑grade deployment. They ensure that agents consistently adhere to organizational standards, policies, and ethical expectations.

OpenTelemetry provides a vendor‑agnostic, standards‑based framework for observing and validating guardrail behavior at runtime. Its unified APIs and emerging generative AI semantic conventions enable organizations to safely instrument guardrail logic, eliminate silent failures, and capture valuable telemetry across decision points.

This session explores the role of guardrails across the entire AI stack, including data layers, infrastructure, orchestration components, and LLMs themselves. We demonstrate how open‑source frameworks such as NVIDIA NeMo Guardrails or OpenLIT can be used to implement production‑ready guardrail mechanisms. Finally, we show how key guardrail metrics such as pass/fail rates, top violation categories, and latency impact can be instrumented using OpenTelemetry and visualized through enterprise observability backends like Dynatrace or Grafana.

You wake up, open X, and see the post: new model just dropped. By the time you finish your coffee, it’s installed, pointed at your repo, and already making “helpful” suggestions. It works. It feels safe. But what did you actually just hand over access to, and how would you even notice if it crossed a line?

In this talk, we’ll unpack why testing every new AI model or coding assistant can quietly introduce serious security risks. Using real examples inspired by incidents like OpenClaw, we’ll show how AI systems can access internal data, influence code paths, and create vulnerabilities without ever asking for permission.

We’ll discuss why experimentation without guardrails can bypass existing security controls and normalize unsafe patterns. Most importantly, we’ll focus on what teams can do instead. The session will include a live walkthrough using the Kubernetes agent-sandbox project to demonstrate how AI agents can be isolated, sandboxed, and constrained with clear boundaries.
By the end, attendees will leave with practical approaches to evaluate AI tools safely, apply guardrails, and enable innovation without putting code or data at risk.

As a developers, we use AI for our tasks. but there are stages.
1. user of web. copy paste code.
2. opencode calude code users basic.
3. using system proimpt PRD driven developement.
4. adding MCP server/ Skills.
5. agentic tools pipelines (code-rabbit)
6. AI Dark factories (gas town)

I have grown from stage 1 to exploring stage 6. creating projects has became trivial with improved models.

Realising tools are there to be tamed but we still need to keep some gaurdrails.

Session will give chronological order how I have grown and How will I develop same project in all stages. using embedded systems example using modbus mcp as well as playwright mcp. in agent.

More over I want to put across the point although AI will make few roles redundant but it will make so many of newer role. How your domain knowledge will help you deliver same projects way faster. passing all minial tasks to AI and perform architectural and review tasks.

Helping AI to write code and Help it to test and fix errors if any. avoiding overfitting.

I will be sharing my personal journey and show How can we achive using FOSS agentic tools for perfect autonomous software facotries.

Predicting how air flows and heat distributes through a physical product is essential for product feasibility studies, performance analysis etc. But it takes hours to days per design variant. You model the geometry, generate a mesh, set up boundary conditions, run the solver, post-process the results. The bigger issue is the back-and-forth between the designer and the simulation engineer. Multiply that by the dozens to hundreds of variants you need to explore a design space, and you get missed deadlines, stale questions, and engineering time spent waiting instead of thinking.
This talk covers usage of OpenFOAM to generate parametric training datasets across geometric and flow parameters with Latin Hypercube Sampling, then train a surrogate model using NVIDIA's PhysicsNeMo framework and its DoMINO (Deep Operator Network for Multi-physics) architecture. DoMINO encodes 3D geometry as a signed distance field, combines it with local surface features, and predicts pressure, temperature, and velocity directly on the part surface in a single forward pass, replacing the entire simulation chain. We'll go through how DoMINO works and why it fits this class of problems.

Learn how to run real AI models fully on-device using Qualcomm’s AI Engine with LiteRT and ExecuTorch. This talk covers architecture, deployment pipelines, performance tuning on NPUs, and real demos showing how to achieve fast, private, low-latency inference on modern AI PCs and mobile devices.