Open Source Summit India 2026

Valkey (forked from Redis) is expected to be fast and correct under an enormous variety of workloads, yet many of the nastiest bugs live outside the reach of traditional unit and integration tests. In this talk, we’ll demonstrate the Chaos Fuzzer for Valkey, built to systematically explore edge cases in the Valkey’s cluster bus, a fundamental part of valkey’s cluster communication model. We’ll show how introducing controlled and uncontrolled chaos into Valkey uncovers correctness issues, subtle crashes, and regression risks that only emerge under common real-world scenarios.

Additionally, we’ll explore how we used Agentic AI to scale fuzzing effectiveness. We will discuss how we leveraged custom AI agents to read, summarize and validate logs from the nodes in Valkey cluster to automatically identify the reasons for cluster failures and expose new bugs in Valkey. We’ll also discuss how AI can be used to generate new fuzzing inputs and scenarios based on prior failures, allowing the fuzzer to iteratively focus on the most error-prone scenarios.

In the end, we will close the talk by discussing how contributors can use this framework to deliver quality features and fixes.

What if every repository in your organisation inherited security, compliance and AI-driven automation the moment it adopted your CI/CD pipeline - with zero extra configuration?

In this session, I'll walk through a fully reusable, open-source-first CI/CD pipeline system built on GitHub Actions/GitLab CI that enforces security and quality gates end-to-end. We'll cover how secret scanning, OWASP Dependency Check, OWASP Dependency-Track, OSV Scanner for container images and SonarQube - community edition for SAST are wired together as non-negotiable pipeline steps - not afterthoughts. I'll demonstrate how Dependabot, Projen and how strict controls actively prevent supply chain attacks before they happen.

Beyond security, the pipeline handles semantic versioning, Cloud deployments, package publishing, artifact management and test report hosting - all reusable across multiple repos.

The talk concludes with the AI layer: using LLMs to auto-generate changelogs, trigger SonarQube self-healing agents and track deployment history for incident response. Attendees will leave with a practical blueprint for adopting OSS tools to build pipelines that are secure, intelligent and built to scale.

ML platforms are powerful, but not always easy to use. A data scientist might understand their model well, yet struggle with Kubernetes configs, SDK APIs, or GPU scheduling. The result is friction — and a lot of “Can someone submit this job for me?” messages.

In this talk, I’ll introduce Kubeflow MCP Server — a Model Context Protocol bridge that exposes the Kubeflow SDK as AI-callable tools. Instead of writing Python or YAML, users can train and manage workloads through natural conversation, while the MCP layer handles validation and policy enforcement underneath.

KEP: https://github.com/kubeflow/community/pull/937

We’ll show:
Turning Kubeflow operations into structured MCP tools
Pre-flight checks that catch resource mismatches before submission
Persona-based filtering so data scientists get safe access while admins keep full control
A two-phase confirmation pattern to avoid accidental large GPU allocations

This session explores what it means for ML infrastructure to become agent-friendly — without compromising governance or cluster safety.

Who owns testing standards in your project? Who decides release gates? Who pays the cost of test debt?

Many open source projects cannot answer clearly. Not because maintainers do not care, but because test health responsibility emerges informally rather than being explicitly defined. What remains informal becomes nobody's obligation until it turns into everyone's problem.

Examining governance docs, contributor guidelines and issue discussions from Linux kernel, Kubernetes, Apache and OpenStack, this talk surfaces a recurring pattern: investing in CI alone does not clarify who owns test health. Kubernetes has a testing SIG and extensive CI, yet flaky test discussions reveal uncertainty about who can enforce fixes.

Four practical steps projects can adopt:

Make testing ownership explicit in governance and contributing documentation.
Define release quality gates that are written, versioned and enforced.
Designate CI health stewardship the way projects designate release managers.
Track flaky test debt the way projects track open issues.

Open source conferences focus on tools. This talk focuses on ownership: a framework for identifying and closing gaps in test health responsibility.

AI is changing software delivery—but most teams don’t need more “chat with logs.” They need an engineering platform that turns delivery signals into reliable, auditable outcomes. In this session, we’ll walk through practical AI patterns for CI/CD and internal platforms using open-source building blocks: pipeline failure triage copilots grounded in CI logs and runbooks, flaky test detection, test prioritization/selection to shorten feedback loops, and change-risk scoring to drive progressive delivery.
You’ll get a reference architecture that treats the platform as a product: a unified “delivery intelligence” layer that connects Git, CI, CD, and observability (OpenTelemetry) into a closed loop—recommend → assist → automate—only within strict guardrails. We’ll cover what makes this production-safe and open-source friendly: evidence-first outputs (no claim without links), policy-as-code boundaries, secrets redaction, prompt-injection defenses, and evaluation harnesses so AI behavior is testable like any other dependency.
Attendees leave with a starter backlog, rollout plan, and metrics to prove impact (cycle time, false-red rate, MTTR, and change failure rate).

Modern platform teams are overwhelmed by reactive operations where manual escalation, delayed remediation, and siloed automation take over. This session presents Event-Driven Platform Engineering as a framework for the design of platforms from ticket-driven systems to autonomous control loops. With the aid of Kubernetes controllers, event streams, policy engines, and real-time telemetry, platforms can identify, decide, and act without recourse to human intervention. We will also look at how events from observability systems, CI/CD pipelines, policy violations, and runtime signals can be transformed into actionable triggers for automation that powers scaling, remediation, governance enforcement, and developer workflows. The talk presents a reference architecture consisting of Kubernetes operators, Prometheus metrics, event brokers, and policy-as-code frameworks for developing self-adaptive internal developer platforms. Attendees will gain a structured approach to designing event-native platforms such as MTTR reduction, SLA compliance, continuous guardrails enforcement, and developer experience enhancement that align with open-source cloud-native environments.