Open Source Summit India 2026

Developing countries face increasing renewable integration, ageing power grid infrastructure and dependence on proprietary energy management systems. This session presents an open, Linux‑powered blueprint for future-ready power grids built entirely on FOSS principles. Aligned with Shell’s inner‑source philosophy, the approach demonstrates how shared innovation, standardized interfaces and reusable components accelerate scalable grid intelligence. Leveraging the LF Energy ecosystem—extending critical modules for load forecasting, system‑state estimation, load flow, voltage control and fault restoration for electric power grids—the architecture shows how community‑driven development reduces vendor lock‑in, lowers deployment costs and enables rapid iteration. For emerging economies such as India, this model illustrates how open collaboration strengthens energy resilience while advancing secure and efficient digital infrastructure to support long‑term energy transition goals.

The Linux kernel can feel impenetrable to newcomers — millions of lines of code and a mailing-list workflow unlike anything else in open source. But what if there was a repeatable, beginner-friendly path in?
During my LFX Mentorship (Fall 2025), which I successfully graduated from, I merged 21 patches across 15+ kernel subsystems — including ext4, gfs2, btrfs, ocfs2, f2fs, mm, tracing, networking, and BPF — all using syzbot bug reports as my starting point.
This lightning talk distills that experience into a practical playbook for first-time contributors:

Finding your first bug: navigating the syzbot dashboard and picking approachable reports like memory leaks and missing validations.
Understanding the bug: reading KASAN/KMSAN reports, tracing call stacks, and using git blame.
Writing the fix: structuring kernel patches with good commit messages following kernel conventions.
Surviving code review: handling v2/v3 revisions and learning from maintainer feedback.

If you have ever wanted to contribute to the kernel but did not know where to start, this talk gives you a concrete, battle-tested roadmap.

AI research is often portrayed as breakthroughs driven by larger models and more compute. In reality, it is an iterative process shaped by uncertainty, failed hypotheses, and refinement. When unstructured, this exploration leads to wasted compute, irreproducible results, and opaque decision-making.

This talk examines AI exploration from a researcher’s perspective, focusing on responsibility and sustainability. From hypothesis formation to experiment design and model comparison, we explore how structured experimentation enables clearer reasoning and accountable research practices.

A central theme is understanding the behavior of every component of an experiment through systematic testing. Models, data pipelines, loss functions, optimization strategies, and training loops interact in complex ways. By isolating and analyzing these components deliberately, researchers can reduce redundant experimentation, improve transparency, and make more responsible use of computational resources.

Attendees will gain practical principles for building reproducible, sustainable, and ethically grounded AI research workflows in open ecosystems.

AI systems handle complex reasoning tasks with fluency, yet consistently fail at simple logic — arithmetic, timezone conversions, unit mismatches — with confidence. The problem deepens when AI agents injest AI-generated code/text: the generator and verifier share the same training distribution, and often the same blind spots. A model that writes a wrong timezone conversion will just as confidently verify it as correct. The error is invisible to both.
This talk presents concrete examples and an empirical study of these shared failure modes. We show which categories of errors are most prone to this — where they silently pass both generation and verification — and show practical approaches to break the symmetry using deterministic validation layers that catch what models miss.

Vibe coding is the latest buzz - the practice of defining your intent and letting AI handle the syntax. But are you doing it right to be the 10x developer, or still struggling with the AI Slop? Open source is currently the battleground for this transition, drowning in "AI Slop" and "AI Pressure".

The problem isn't isolated with the AI capabilities; our outdated developer mindset is to be blamed too. We are still treating syntax as the primary asset and writing documentation for human consumption.

We are introducing the new paradigm: In the age of vibe coding, code is a use-and-throw commodity. The true IP of your project is the context, the historical decisions, the constraints, and unwritten rules.

In this session, lets explore how to stop fighting AI agents buy designing for them. We will move beyond the traditional "human-in-the-loop" defense and embrace a new reality of Context Engineers.

Key Takeaways
* Understand the mechanics of AI-assisted coding.
* Why source code is becoming a disposable commodity, and the project context is the new asset.
* Actionable strategies to help AI understand your project's knowledge base.
* How to adapt TDD to validate AI intent.

Every token sent to an LLM costs money. When you serialize data as JSON for a prompt, you pay for repeated field names, extra braces, and structural noise on every single row. For large datasets that overhead runs to 40-60% of your token bill & it adds nothing useful to the prompt.

TOON (Token-Oriented Object Notation) is a compact, human-readable format built specifically for LLM prompts. It writes column headers once and streams data as plain rows, similar to CSV, but with full support for nesting, arrays, and schema markers. The result is 40-60% fewer tokens with measurably better LLM accuracy: 73.9% one-shot vs JSON's 69.7% on tabular tasks.
​
This talk covers the TOON format from the ground up: why it exists, how it encodes data, when it wins over JSON and when it does not, and how to use it in real LLM prompts today.

Finally we walk through the toon4s-spark integration, connecting Apache Spark and Databricks to TOON and streaming patterns on Delta Lake.

You will leave knowing exactly how to cut LLM prompt costs, with a format and library you can adopt from any JVM stack today.

Check-
https://github.com/com-vitthalmirji/toon4s
https://toonformat.dev/

Current evaluation methods for AI agents, which depend on static benchmarks, are in adequate for real-world systems. This session reveals why accuracy-centric evaluations create a dangerous illusion of readiness and how real systems—shifting APIs, incomplete signals, tool failures, cascading dependencies, and environment drift—expose brittleness that benchmarks never measure. We introduce and demonstrate a chaos engineering driven AgentCert approach as an open source project, developed through a collaborative effort of Infosys and Microsoft, that evaluates agents the way real infrastructure tests resilience: by injecting controlled faults, observing recovery behavior, and measuring adaptation under stress. Participants will learn how scenario-based fault models, workload-coupled tests, and observability-rich metrics uncover latent weaknesses and emergent behaviors. The session presents a practical, open, and repeatable framework for certifying agents on robustness, not just correctness—empowering teams to build AI agents that remain stable, safe, and dependable when reality gets messy. See https://github.com/AgentCert for more details.