TechXConf 2026

As Enterprise AI Agents gain the ability to access data, invoke tools, trigger workflows, and influence business decisions, traditional governance processes struggle to keep pace. Most organizations rely on manual reviews, spreadsheets, and policy documents to assess agent risk, resulting in in consistent evaluations and limited scalability. This session introduces an AI-powered governance approach that automates the assessment of enterprise AI agents. Using a risk-tiered control framework, a governance agent analyzes an agent's autonomy, data access, external connectivity, decision impact, and action capabilities to determine its risk level and validate whether appropriate controls are in place. Attendees will learn how AI can be used to classify agents, identify missing controls, validate governance requirements, and generate deployment recommendations. Through practical examples and a few demonstration, the session will showcase how organizations can move from manual governance reviews to continuous, scalable AI agent oversight while balancing security, compliance and innovation.

This session explore the unique attack surface exposed by autonomous Agentic AI systems in the real-world applications. When large language models are granted tool execution privileges, persistent memory, and multi-step planning capabilities, traditional application security models and network safeguards are no longer enough to keep systems secure. We will dive deep into critical LLM and Agentic AI vulnerabilities with examples and live Demos. We will also talk about practical controls that can be applied to mitigate the risks. This session will cover following: - Direct and indirect prompt injection - Tool misuse and unauthorised access - Identity and privilege escalation - Memory and context poisioning - Sensitive information disclosure etc.

In this session, I will share case studies from my own work across technical documentation, SME workflows, Developer Relations, and AI projects. The first case study looks at a documentation and operations workflow involving SOPs, articles, policies, spreadsheets, and CMS publishing. I will show how AI agents and MCP can support anomaly detection, reusable skills, verification, and workflow automation. A key focus will be Design Based on Role, Not Based on Task. Instead of asking what individual task AI can automate, we look at the complete role, its responsibilities, decisions, context, dependencies, and repetitive work. This helps identify what an agent should execute, what it should assist with, and what must remain human controlled. The second case study covers building a technical knowledge base from scratch using AI agents and modern AI tools. I will share how context was structured, how reusable skills were developed, and how hallucinations, AI slop, privacy concerns, and manual verification were handled. Session Highlights • Design Based on Role, Not Based on Task: Design AI workflows around the complete role, not isolated tasks. • The Human Verification Tax: Identify where AI actually saves time and where humans are still checking every output. • Skills, Not Giant Prompts: Convert repeatable expert processes into reusable agent skills. • Context as an Engineering Layer: Decide what context an agent needs and what it should retrieve. • MCP as the Tool Layer: Connect agents with documentation, CMS, spreadsheets, and knowledge systems. • AI Slop at Scale: Understand why AI generated content can become a quality problem and how to build quality gates. • Agent Boundaries: Define what agents can execute, what requires validation, and what stays human owned. • From Knowledge to Action: Move from AI answering questions to AI operating within a governed workflow. • Failure First: Learn from real examples of hallucinations, incorrect context, privacy issues, and failed automation. Takeaway Attendees will leave with a practical framework for designing AI workflows around real professional roles: Role → Context → Skills → Tools → Agent → Validation → Human Decision The goal is not to automate everything. It is to understand what AI should execute, what it should assist with, and what humans should continue to own. Format 20 to 30 minute technical session The session will use architecture diagrams, workflow maps, personal case studies, and practical strategies.

Enterprises scaling AI from pilot to production often default to "more GPUs" as the answer to every workload — quietly driving up cost, energy consumption, and time-to-deploy without ever asking whether the hardware actually matches the job. In a landscape where infrastructure decisions compound rapidly, this default is expensive, inflexible, and increasingly unsustainable. Choosing the right compute substrate — CPU, GPU, or TPU — is one of the highest-stakes architectural decisions an engineering team makes. Yet most teams lack a structured framework for making it well. This talk introduces a practical, workload-first decision framework grounded in three dimensions that matter most: workload shape, latency requirements, and power envelopes. We map these dimensions against the full spectrum of modern AI data centre architectures — each purpose-built for specific use cases rather than generic, one-size-fits-all deployments: • Dense GPU clusters — optimised for large-scale distributed model training • Hybrid CPU pipelines — delivering cost- and energy-efficient inference at scale • Disaggregated infrastructure (e.g., IBM LinuxONE) — purpose-built for data residency, compliance, and hybrid cloud workloads • Edge-to-core designs — engineered for latency-bound, real-time inference at the boundary • Ocean- and sea-based data centres — leveraging natural cooling environments to dramatically reduce energy and water footprint at scale Each model represents a deliberate architectural trade-off. Getting these decisions right pays off directly in time-to-market, sustainability metrics, and unit economics. Getting them wrong locks organisations into rigid, over-provisioned infrastructure that is costly to unwind. This session is designed for engineers, architects, and technical leads who need to move beyond instinct and vendor defaults — and make compute decisions they can defend with data. Key Takeaways 1. A workload-first decision framework for choosing between CPU, GPU, and TPU — based on workload shape, latency tolerance, and power constraints, not convention or vendor pressure 2. A practical map of purpose-built data centre models — from dense GPU clusters and disaggregated hybrid infrastructure to edge-to-core and ocean-cooled designs — and the specific use cases each one is engineered to serve 3. A framework linking infrastructure choices to business outcomes — connecting compute decisions directly to time-to-market, sustainability goals, and unit economics so technical teams can align with organisational priorities

A comprehensive guide to building reliable, enterprise-grade AI agents by separating reasoning from execution. Moving beyond simple single-prompt LLM calls, this book introduces a structural blueprint centered on Loop Engineering (the dynamic self-prompting and iterative decision cycle) and Harness Engineering (the surrounding execution environment of tools, state management, and guardrails). Learn how to design resilient agent systems that can autonomously plan, execute, verify, and self-correct with minimal human intervention.

AI agents are evolving from assistants that recommend products to agents that can execute commerce transactions. This session explores how UCP, MCP, A2A, and AP2 enable this shift. Using a practical reference architecture, we’ll show how these emerging protocols work alongside existing APIs and AI agents to reduce integration complexity and deliver standardized, interoperable, and governed agentic commerce, and we’ll close with a phased path for adopting them.

The session will demonstrate how AI evaluation can be automated and integrated into a repeatable testing workflow, allowing teams to identify regressions as models, prompts, data, and application logic evolve. Attendees will leave with a practical approach to testing AI applications and a foundation for building their own AI Quality Engineering strategy using open-source tools.

Fun Show

This session covers what changes technically when an AIoT device moves from reporting data to taking physical action on its own. The reliability arithmetic. Why per-decision accuracy is the wrong metric for an autonomous device, how duty cycle converts an ordinary error rate into hundreds of wrong physical actions per node per day, and why agent reliability measured across repeated runs falls far below its single-run benchmark figure. Architecture and its constraints. How to partition an AIoT workload across device, edge and cloud so it survives connectivity loss; what a quantised model actually costs in accuracy; the flash, RAM and power ceilings that determine model size on a microcontroller; and where deterministic rules remain the correct engineering answer rather than a compromise. New failure classes. The risks that appear only when AI gains actuator access — excessive agency, poisoned sensor context, chained tool authority, memory poisoning and emergent fleet behaviour — mapped against the OWASP Top 10 for Agentic Applications, with a worked example of a prompt injection that produces a physical result. The guard pattern. A deterministic policy layer between model and actuator: closed command schema, bounded parameters, rate limiting, confirmation on state change, and audit logging of rejected intents. Roughly forty lines of code, containing no intelligence, and therefore provable. Includes measured results from real hardware and a pre-production checklist for AIoT autonomy.

AI is changing how security teams investigate threats. Instead of analysts manually switching between multiple tools, AI-powered security agents can orchestrate investigations, gather evidence, correlate context, and assist analysts with faster decision-making. In this session, we will explore how AI agents can be applied to real-world Security Operations, including alert investigation, evidence collection, tool orchestration, and analyst assistance. We will also look at how Model Context Protocol (MCP) can connect AI agents with security tools and data sources to create a more unified investigation workflow. The session will focus on practical architecture, real-world use cases, and the opportunities and challenges of bringing AI agents into cybersecurity operations.

This session demonstrates a practical AIOps use case built and tested on OCI: automatically collecting and analysing cloud cost information, identifying opportunities for optimization, and using Generative AI to convert operational data into meaningful recommendations and actions. The solution brings together OCI Functions, Object Storage, Resource Scheduler, cloud automation, and OCI Generative AI, showing how AI can become part of day-to-day cloud operations rather than remaining a standalone chatbot or experimental capability. The objective of this session is to demonstrate how Generative AI can evolve from answering questions to actively participating in cloud operations—understanding operational data, recommending decisions, and safely triggering automated actions. Live MVP Demo will be shared during the session. How can we move from simply observing our cloud environment to having AI understand it, recommend actions, and automate the response?

AI agents can reason, plan, and act, but many real-world decisions eventually become constrained optimization problems. This session explores how hybrid quantum-classical computing can help AI agents tackle such problems. Through a live end-to-end demo, we will build an AI agent that formulates a cloud resource allocation problem as a QUBO and compares classical and quantum optimization approaches. We will evaluate solution quality, cost, SLA compliance, and execution time, while discussing where quantum computing can realistically add value to modern AI systems.

AI agents can already detect anomalies, suggest fixes, and even trigger rollbacks. In this talk, I'll explore how AI is starting to reshape DevOps workflows — from intelligent monitoring to self-healing CI/CD pipelines — and share a working example of integrating AI-driven decision-making into a deployment pipeline. Is this the future of DevOps, or just smarter automation? We'll dig into both the promise and the limits.

AI is accelerating how quickly developers can create software, but the complexity behind delivering and operating that software continues to grow. Cloud, Kubernetes, security, observability, compliance, networking, and now AI-powered development are creating more cognitive load than individual development teams should be expected to manage. In this session, we will explore why platform engineering matters more in the AI era, how internal developer platforms can turn infrastructure complexity into reusable self-service capabilities, and why the platform should be designed around developer problems rather than platform-team assumptions. We will also look at how platforms are evolving from serving only human developers to safely exposing capabilities to AI-assisted workflows and agents. The key question is simple: **as development gets faster, who owns the complexity behind it?**

Enterprises already have enormous amounts of data spread across databases, lakehouses, event streams, documents, support systems, images, and other operational platforms. The challenge is no longer just storing or moving that data. The harder problem is giving machines a governed, queryable understanding of what the business actually is, including its entities, relationships, meanings, current state, and provenance. This session explores how modern data engineering can evolve from traditional pipelines into an enterprise context layer. The architecture combines multimodal ingestion, entity resolution, ontology engineering, knowledge graphs, temporal state, lineage, provenance, and runtime context assembly. A Knowledge Graph represents the persistent structure of the enterprise, including customers, products, contracts, suppliers, tickets, people, and the relationships between them. A Context Graph is then dynamically assembled for a specific question or decision, selecting only the relevant entities, facts, documents, events, and relationships from the larger enterprise knowledge base. Using a practical scenario such as identifying enterprise customers at risk of churn, the session demonstrates how structured data, support history, contracts, account relationships, product usage, and external signals can be combined into a small, evidence-backed context graph that is explainable and traceable to its original sources. The key idea is simple: The Knowledge Graph represents what the enterprise knows. The Context Graph represents what matters right now. The session presents a practical blueprint for moving from Data → Identity → Meaning → Knowledge → State → Context → Decision, and shows how the next generation of data platforms can become machine-readable foundations for analytics, applications, and AI.

Fun Show

Banks are racing to deploy AI copilots and chatbots on top of internal data - risk reports, transaction logs, compliance docs, customer records. But in a regulated, high-stakes domain, a fluent-sounding wrong answer isn't just embarrassing, it's a compliance and financial risk. This talk breaks down how to engineer trust into AI systems as a property of the data pipeline, not a claim the model makes about itself. I'll walk through a practical architecture - built during a recent hackathon — that scores every AI-generated answer on provenance (can you trace it back?), source reliability, freshness, and cross-source agreement, and makes every claim clickable back to its exact origin (file, row, page, timestamp). I'll also cover why letting an LLM self-report its own confidence is unreliable, and why deterministic signals from the data layer matter far more - especially for banking, where auditability and regulatory traceability aren't optional. Attendees will leave with a concrete mental model (and reference architecture) for adding a "trust layer" to any RAG system, with specific considerations for financial data: PII handling, audit trails, conflicting source reconciliation, and stale-data risk in fast-moving markets.

Most AI fails because of messy data, not bad algorithms. In this interactive session, we’ll look under the hood at how to build a clean data foundation that keeps AI smart, accurate, and reliable. Through quick questions and a live side-by-side demo, you'll see how real-time pipeline design and smart data storage stop AI hallucinations before they start.

We live in a World of Data. We need data for almost every Analytical purpose. Financial institutions are one among the Major sectors using Data especially in Trade and investment, Tax reform, Fraud detection and Investigation and Risk Analysis. We will have quick overview of a live use case and how we helped the client to tackle a real time problem by setting up an Automated Quality Controls process for Data Delivery to Analysis Teams. The Client had a problem statement of running 2000+ Database queries across 180+ DB tables across different Delivery checkpoints. This was manual, much time consuming and prone to manual error. The Data delivered to downstream systems was through different Business Layers, some in Hadoop, a few in Oracle and a few in files. I from Automation perspective saw the pattern of these queries and how we can simplify the whole process. I harnessed the power of Robot Framework and suggested to Automate the queries and we call it Data Quality Controls. We used Robot Framework and Automated 2000+ Controls and this serves as entry and exit checkpoints at each Business level. These Data Quality Controls run every month to ensure accuracy, completeness, consistency, validity and no wrong data is supplied to the DownStream system. Framework Architecture: We build a Hybrid Test Automation Framework with Page Object Model, combined with Keyword and Data Driven Architecture to cater our needs. Tech Stack: Hadoop, HDFS, Oracle, Unix and Python Test Automation: Robot Framework with Python

Shipping to production is often treated as the finish line. In reality, it is where software begins encountering the conditions that development environments cannot fully reproduce: unexpected traffic, partial failures, slow dependencies, resource exhaustion, configuration drift, noisy alerts, and real users doing unpredictable things. In this practical, demo-driven session, we will take a seemingly healthy application from “works on my machine” to a production incident and uncover the hidden engineering costs that appear after deployment. Through a live demonstration, we will introduce realistic failure scenarios such as increased traffic, service timeouts, dependency failures, memory and CPU pressure, and cascading errors. We will then use observability and reliability techniques to identify what went wrong and progressively improve the system. The session will explore observability, logging, metrics, distributed tracing, health checks, timeouts, retries, graceful degradation, alerting, capacity planning, and incident debugging. We will also examine how architectural decisions made during development can directly influence production reliability and operational complexity. The goal is not to discourage teams from shipping quickly, but to show what responsible “ship it” engineering looks like—and how developers can design systems that are easier to operate, debug, and recover when things inevitably go wrong.

In this talk, I will describe the core challenge of building causal analysis systems for mechanistic interpretibility and walk through my idea of Activation Sensory Transducers. The main focus of the talk is to show how current tools around mech interp for human-in the-loop AI model safety guardrails are fundamentally limiting - as they focus on text and linguistic channels to convert activations and outputs trained autoencoders into features. This approach can result in errors and misleading outputs for human observation. I will explain the main concept of transducing the activation maps to a human sensory outputs and enabling an alternative way to detect model mislaignments. I will show how we can use senses like sound (sonification of activations), sight (MNE python used as a neuroscience visualisation tool) to demonstrate how we can convert GPT2 activations in sensory outputs. This concept has been presented in Scientific Python US conference 2026 as a reasearch paper and a poster presentation. It is also accepted by Euro Scientific Python 2026 My Slides: https://docs.google.com/presentation/d/1PM-NrVYKe-eAMDUJTU5TqV-3ICtJ2DAM9-YKtCWsi3A/edit?usp=sharing My research paper: https://proceedings.scipy.org/previews/019f571b-4ffd-7ff6-95ac-0b5e0d94540b?preview=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJodHRwczovL3NjbXMuY3VydmVub3RlLmNvbSIsImV4cCI6MTc4NzAyMTQ0MiwiYXVkIjoic2Ntcy1wcmV2aWV3Iiwic2NvcGUiOiJzdWJtaXNzaW9uIiwic2NvcGVJZCI6IjAxOWY1NzFiLTRmZmQtN2ZmNi05NWFjLTBiNWY1MWY1MzYxMyIsImlhdCI6MTc4NjU4OTQ0Mn0.K8MjEno20DQoRlgAnofOfx2hizStm4-UymHwtqA9M2k My Previous talk references are at sharmaviraj.com

As LLM-powered intelligent applications/systems continue to grow at an unprecedented pace, ensuring their safety, reliability, and trustworthiness goes far beyond setting guardrails. LLM observability provides deeper visibility into prompts, responses, hallucinations, failures, and safety violations, enabling teams to identify blind spots and continuously strengthen AI safeguards. This talk explores how observability transforms guardrails from static controls into an evolving defense mechanism, empowering developers to build AI systems that are more transparent, resilient, secure, and responsible. Discover the synergy between observability and guardrails in advancing AI towards trustworthy intelligence.

Microsoft Fabric brings data engineering, analytics, real-time intelligence, data warehousing, Power BI, and AI together on a unified platform. In this session, we’ll explore how Fabric simplifies modern data architecture and enables organizations to build scalable, intelligent, and end-to-end data solutions. The session will cover key Fabric workloads, OneLake, Lakehouse architecture, Data Pipelines, Spark, Data Warehouse, Real-Time Intelligence, semantic models, and AI-powered capabilities, with a practical perspective on how these components work together in a modern data ecosystem

Fun Show