Sneha Sankaran
Automotive Software Product Owner & AI Practitioner, Bosch | Agentic AI | MCP | Safety-Critical Engineering
Coimbatore, India
Actions
Sneha Sankaran is an Automotive Software Product Owner and AI Practitioner at Bosch with over 10 years of experience spanning requirements engineering, full-stack software development, system design, testing, and validation in safety-critical environments. She specializes in bridging the gap between cutting-edge autonomous AI frameworks and the rigorous engineering standards required by global enterprise operations.
On the development side, Sneha focuses on the end-to-end translation of complex multi-agent backend logic into high-utility developer experiences. Her architectural work includes designing Model Context Protocol (MCP) tool schemas and custom interface endpoints directly within integrated environments like VS Code extensions and Claude Desktop.
Engineering & Hackathon Milestones:
1st Place Winner: Microsoft Reactor Hackathon (Agentic System Architecture category) for the Agile Sprint Orchestrator.
Enterprise Operationalization:
Co-architected and successfully deployed the agentic framework within active production engineering pipelines at Bosch.
Live Technical Delivery:
Expert in live architecture walk-throughs, system execution telemetry, and interface deployment demonstrations
Links
Area of Expertise
Topics
Building MCP Tools for AI Developer Workflows
AI agents become useful to developers when they can interact with real tools—but tool access introduces new challenges around permissions, validation, and reliable execution. In this hands-on workshop, participants will build a small agentic developer workflow using the Model Context Protocol (MCP), connecting an LLM to controlled file and Git operations through explicit tool interfaces.
Starting from a prepared repository, we will build a three-stage pipeline that parses a development task, proposes or performs a constrained operation, and validates the result using deterministic checks. Participants will explore local and cloud model configurations, structured tool inputs and outputs, workflow state, and human approval for sensitive actions. The workshop emphasizes reproducible implementation, practical security controls, and a working project that attendees can adapt to their own development workflows.
Key takeaways from the session:
- Implement an MCP server exposing a small set of controlled developer tools.
- Validate tool inputs and outputs using explicit schemas and deterministic checks.
- Coordinate multiple workflow stages while preserving state and error handling.
- Apply permissions, workspace restrictions, and human approval to sensitive operations.
Beyond Code Gen: Engineering a Multi-Agent Factory
AI coding assistants are great for individual developers, but building an autonomous multi-agent pipeline across a team's entire agile sprint workflow surfaces harsh architectural realities. Moving past basic prompt engineering requires designing strict integration boundaries, robust state management, and deterministic validation layers.
In this highly practical case study, we pull back the curtain on a 7-phase agentic software factory spanning backlog refinement to automated verification. We will examine the real-world friction of multi-agent orchestration, the technical realities of context window depletion, and how we balanced lightweight local execution (Phi via Ollama) with large cloud models. Attendees will walk away with a practical blueprint for using the Model Context Protocol (MCP) to securely connect AI agents directly to local IDEs and deployment pipelines without breaking corporate compliance frameworks.
What you will learn:
- Orchestration Patterns: Design patterns for coordinating reliable state handoffs between specialized AI agents.
- Deterministic Safety: Implementing schema-driven validation gates to safely contain non-deterministic LLM behavior.
- MCP Integration: Practical strategies for utilizing Model Context Protocol to hook models securely into local developer workspaces.
Attacking the Factory: Securing AI Agents from Injection to Execution
When an AI agent is given a tool interface to read, write, and execute code within an enterprise pipeline, it becomes a high-value target for emerging threat vectors. If an untrusted input introduces a prompt injection, or if an agent autonomously processes a malicious pull request, the security blast radius can instantly compromise your engineering environment.
This session breaks down the security architecture of a multi-agent software factory using Model Context Protocol (MCP) and Azure OpenAI. We will demonstrate practical attack scenarios—including indirect prompt injection and excessive permission exploitation—to illustrate exactly how autonomous agents can be manipulated. Moving beyond the threats, we will design a robust, zero-trust defensive framework. You will learn how to build secure tool execution sandboxes, implement runtime monitoring, and establish automated guardrails to intercept malicious agent behavior before it touches production infrastructure.
Participant Takeaways:
- Threat Modeling Agents: Identifying vulnerabilities in multi-agent architectures, focusing on prompt injection and tool-abuse vectors.
- Secure MCP Architecture: Engineering isolated, least-privilege tool execution environments for Model Context Protocol integrations.
- Agent Observability: Implementing logging, auditing, and telemetry to detect and alert on anomalous AI system behaviors in real time.
Local AI at the Edge: Orchestrating SLMs via Ollama
Sending massive volumes of proprietary enterprise source code to external cloud AI APIs introduces severe challenges around network latency, API costs, and data data privacy. The alternative? Moving your execution boundaries to the edge by deploying Small Language Models (SLMs) locally on engineering hardware.
This deep technical session deep dives into the mechanics of running and orchestrating local developer agents. Leveraging the high-performance Go-based architecture of Ollama alongside lightweight models like Phi, we look at how to maximize local hardware compute for agentic workflows. We cover the engineering realities of running parallel local workloads, context window optimization strategies, and the design patterns necessary to handle fallback routines when local models hit reasoning limitations. If you want to build fast, private, and zero-cost AI automations directly on developer machines, this session is for you.
What you will learn:
- Edge Architecture: Setting up and scaling local SLM endpoints utilizing Ollama's high-performance runtime engine.
- Resource Engineering: Managing memory, inference latency, and concurrency constraints when running multi-agent tasks locally.
- Hybrid Failover Design: Implementing secure, conditional routing patterns to pass complex reasoning tasks to cloud environments only when required.
Hybrid AI: Balancing Local SLMs with Azure
When deploying autonomous workflows in production, architects hit a stark crossroads: the localized privacy of small language models versus the raw reasoning capabilities of the cloud. This fast-paced lightning talk breaks down the technical, economic, and security boundaries that dictate how to split workloads between local environments (Phi via Ollama) and cloud engines (Azure).
We bypass the theoretical marketing hype to dissect real-world performance metrics: context window depletion, round-trip API latency, API token consumption costs, and strict data perimeters. Attendees will walk away with a production-tested decision matrix for securely routing tasks across a hybrid AI infrastructure.
What you will learn:
- The Scaling Formula: Mapping simple tasks to local hardware while escalating complex reasoning to Azure AI.
- Performance Metrics: Cold analytics comparing execution speeds, API round-trips, and compute overhead.
- Compliance Perimeters: Architecting a data wall to protect corporate assets while leveraging cloud intelligence.
Guarding the Pipeline: Zero-Trust Security for AI Agents
Giving autonomous AI systems the capacity to write code, call shell tools, and execute scripts inside an engineering environment creates massive new security attack vectors. From indirect prompt injections hidden in untrusted git branches to excessive tool execution permissions, a misconfigured agent can quickly become a malicious pipeline threat.
This security architecture talk maps out a complete Zero-Trust defensive framework for running agentic systems in enterprise environments. Using our multi-agent software factory as a live model, we dissect how to build secure, isolated execution sandboxes for Model Context Protocol (MCP) tools. We explore how to manage non-human operational identities, implement strict API traffic gating, and construct automated verification layers that intercept and quarantine unauthorized agent actions before they compromise infrastructure.
What you will learn:
- Threat Vector Analysis: Identifying security vulnerabilities unique to autonomous systems, including prompt injection and privilege escalation.
- Sandboxed Execution: Implementing isolated runtime perimeters around automated tools to minimize agent blast radiuses.
- Identity Gating: Best practices for authenticating and logging agentic machine-to-machine communications across corporate networks.
Exposing Azure OpenAI to the IDE via MCP
The true value of an AI agent isn't its underlying model, but its ability to securely interact with the developer's environment. This session delivers an architectural deep dive into connecting Azure endpoints directly into local IDEs like VS Code using the Model Context Protocol (MCP).
We look at an enterprise case study of a 7-phase agentic software orchestrator, showing how to safely expose file systems, shell commands, and git operations to cloud intelligence. We will detail how to construct deterministic validation schemas to contain non-deterministic model behaviors, manage context token efficiency, and design secure tool authentication layers that satisfy corporate governance.
What you will learn:
- MCP Infrastructure: Setting up secure, custom Model Context Protocol servers to bridge local workspaces with Azure OpenAI.
- Validation Guardrails: Implementing strict schema-driven checks to safely intercept unauthorized agent actions.
- Context Window Engineering: Advanced prompting strategies to prune data inputs and maximize model efficiency.
Zero-Trust Security for Autonomous AI Agents
Granting autonomous AI systems the capacity to read source repositories, call shell tools, and execute scripts inside a corporate network introduces massive new security vulnerabilities. From indirect prompt injections hidden in untrusted git branches to excessive tool execution permissions, a misconfigured agent pipeline can quickly turn into a critical internal threat vector.
This security architecture session maps out a complete Zero-Trust defensive framework for hosting and running agentic automation systems. Using a live multi-agent software factory as our blueprint, we explore how to build secure, isolated tool execution sandboxes using modern containerization and network gating. We cover how to securely authenticate machine-to-machine tool access via Model Context Protocol (MCP), manage non-human workload identities, and construct automated verification layers that quarantine malicious agent behavior before it touches production infrastructure.
What you will learn:
- Threat Modeling Agents: Analyzing vulnerabilities unique to autonomous systems, focusing on prompt injection and tool-abuse vectors.
- Sandboxed Execution: Engineering isolated runtime perimeters around automated tools to minimize an agent's network blast radius.
- Identity & Logging: Best practices for authenticating, authorizing, and auditing agentic machine-to-machine actions across corporate networks.
Zero-Trust Governance for Autonomous AI Agents
Granting autonomous AI systems the capacity to read enterprise source repositories, call terminal tools, and execute scripts creates massive new security vulnerabilities. From indirect prompt injections hidden in untrusted git branches to excessive tool execution permissions, a misconfigured agent pipeline can quickly become a dangerous internal threat vector.
This session maps out a complete Zero-Trust defensive and architecture framework for orchestrating agentic automation systems safely on Azure. Using our multi-agent software factory as a live case study, we explore how to build secure, isolated execution sandboxes for Model Context Protocol (MCP) tools using Azure Container Apps. We dissect how to establish clear data perimeters, manage non-human identity lifecycles, and implement automated audit logging to capture unauthorized agent behaviors before they touch core cloud infrastructure.
What you will learn:
- Agent Threat Modeling: Analyzing unique vulnerability profiles of multi-agent systems, focusing on prompt injection and tool abuse.
- Secure Infrastructure Design: Engineering sandboxed container runtime perimeters using Bicep Infrastructure-as-Code (IaC).
- Compliance & Identity Gating: Best practices for authenticating, authorizing, and auditing agentic machine-to-machine actions across corporate networks.
Predictive Sprints: Moving from Tracking to Autonomy
For decades, agile frameworks have relied heavily on reactive tracking metrics—velocity charts, burndown paces, and subjective status updates—to measure organizational health. However, as software environments grow more complex, these manual rituals frequently fail to detect hidden dependencies and cognitive overload until a sprint has already failed. When an organization introduces an autonomous multi-agent pipeline into its product delivery workflow, the core challenge rapidly shifts away from simple code generation toward structural team evolution and decision intelligence.
This session presents a real-world case study of a 7-phase agentic sprint orchestrator deployed within a safety-critical corporate engineering environment. We analyze the architectural shift of moving from traditional project management tools to a predictive system powered by 10,000-run Monte Carlo simulation engines. Moving past the technical implementation, we dissect the profound impact this automation has on team dynamics: how it changes the role of the Scrum Master, transforms requirements engineering, and alters collaboration between business units and IT. We will share the exact organizational and architectural friction points we encountered, detailing how we built deterministic safety guardrails to ensure human-in-the-loop accountability.
What you will learn:
- Organizational Shift: How multi-agent systems reshape traditional agile roles, transforming scrum teams from reactive trackers into predictive designers.
- The Guardrail Blueprint: Designing architectural boundaries and validation layers that securely gate non-deterministic AI decisions before execution.
- Cross-Phase Intelligence: Utilizing cross-sprint memory patterns to automatically surface and resolve systemic team overcommitment and friction.
What Broke When We Engineered an Agentic Software Factory
AI coding assistants accelerate individual developers, but things break down when you try to introduce an autonomous multi-agent pipeline across an entire software delivery workflow. In this case study, we dissect the architectural journey and engineering friction of scaling an award-winning agentic prototype toward enterprise reality.We skip the standard AI hype to share five hard reality checks encountered during production architecture: why adding more agents degraded systemic autonomy, how we handled complex multi-agent state coordination, and how we balanced local execution (Phi via Ollama) against cloud APIs (Azure OpenAI) under strict enterprise constraints. You will walk away with a practical architectural blueprint for engineering deterministic validation gates to safely contain non-deterministic LLM behavior within production pipelines.
Takeaways:
- Architecture Blueprint: Decomposing multi-phase developer workflows into predictable, specialized agent pipelines.
- Deterministic Safety: Designing validation schemas and guardrails to control non-deterministic AI decisions.
- Local vs. Cloud Analytics: Trade-offs of mapping execution layers to local hardware vs. cloud compute under enterprise data perimeters.
Who Signed That Commit? Architecting Entra Workload Identities for AI Agents
In an autonomous development workflow, agents act on behalf of users, services, and entire teams. But when an AI system commits code, updates an agile backlog, or triggers a deployment pipeline, traditional user-based authentication models completely fall apart. To maintain accountability and prevent credential abuse, enterprises must treat AI agents as distinct, manageable non-human identities.
This deeply technical architecture session uses our 7-phase agentic software orchestrator to demonstrate how to implement enterprise-grade authentication and authorization frameworks. We will explore how to map multi-agent pipelines to Microsoft Entra Workload Identities and non-human IDs, ensuring every agent operates under strict least-privilege constraints. We will dissect token management across local infrastructure (Phi via Ollama) and cloud APIs (Azure GPT-4o), and outline how to handle access lifecycles so you can confidently answer the ultimate audit question: Who authorized this agentic action?
Participant Takeaways:
- Entra ID Integration: Designing a least-privilege framework using Entra Workload Identities tailored specifically for autonomous AI agents.
- Token & Lifecyle Management: Best practices for secure authentication handoffs across a multi-stage local and cloud AI pipeline.
- Auditing & Accountability: Establishing clear cryptographic and identity trails to link agent actions back to human owners and compliance frameworks.
Governing the Factory: Securing Multi-Agent AI in the Enterprise
As enterprise IT rapidly transitions from basic AI chatbots to autonomous multi-agent software factories, the core challenges migrate away from prompt engineering toward deep identity, security, and governance boundaries. When AI agents are granted the autonomy to interact with enterprise source code, modify repositories, and orchestrate agile sprints, how do we prevent agent sprawl, ensure human-in-the-loop accountability, and maintain strict data perimeters?
In this highly technical architecture session, we dissect the deployment of an award-winning 7-phase agentic software pipeline into a compliance-focused enterprise environment. We will bypass the initial prototype hype to focus entirely on the operational reality checks: managing non-human workload identities, drawing clear compliance boundaries between local environments (Phi/Ollama) and cloud systems (Azure OpenAI), and using Model Context Protocol (MCP) as a secure integration gate. Through real-world lessons and live architectural demonstrations, you will learn how to design deterministic verification layers that safely contain non-deterministic AI actions within your existing corporate governance framework.
Participant Takeaways
- Agent Identity & Least Privilege: Designing security perimeters around autonomous non-human workloads to prevent excessive access across enterprise environments.
- Deterministic Governance Gates: Implementing strict validation schemas and human-in-the-loop checkpoints to verify non-deterministic AI decisions before execution.
- Local vs. Cloud Data Perimeters: Navigating the trade-offs of performance, cost, and compliance when balancing local hardware containment against cloud models.
- Secure Tool Integration: Utilizing Model Context Protocol (MCP) safely as an authenticated integration boundary inside modern developer workspaces.
Model Context Protocol: The Integration Boundary for AI Agents
The greatest bottleneck in building effective AI agents isn't the model's reasoning capability; it is the integration boundary where the LLM connects to actual developer tools, file systems, and environments. This session delivers a deep-dive technical look at utilizing the Model Context Protocol (MCP) to bridge that gap safely.We will walk through how we implemented MCP tools to expose shell, file, and git capabilities safely within a 7-phase agentic software pipeline. We will explore how to expose orchestrator capabilities directly to VS Code and Claude Desktop workspaces, manage context windows efficiently, and design secure tool interfaces that minimize the risk of destructive actions. This talk features live code demonstrations of functional MCP servers designed for advanced engineering automation.
- Takeaways:
- MCP Infrastructure: Setting up and configuring secure Model Context Protocol servers inside real-world developer environments.
- Secure Tool Design: Writing robust schemas that expose environment capabilities to AI agents without risking pipeline execution.
- Context Window Engineering: Techniques for pruning and filtering data streams to maximize prompt context efficiency.
Governing Autonomous Agents in Large Environments
Giving autonomous AI systems the agency to analyze backlogs, execute scripts, and interact with live repositories introduces severe friction between two corporate forces: the developer's desire for velocity and the architect's mandate for systemic safety. In large, non-hierarchical environments, this tension intensifies. How do you govern a workforce of autonomous software agents without implementing rigid, bureaucratic hierarchies that kill organizational adaptability?
We tackle this dilemma by analyzing the structural governance framework designed for our multi-agent software factory. We will look at the explicit trade-offs of mapping execution layers across a hybrid cloud/edge topology, balancing fast, privacy-first local small language models (Phi) with deep cloud reasoning models (Azure OpenAI). We will share our real-world failures and breakthroughs in establishing data perimeters, managing non-human operational identities, and utilizing Model Context Protocol (MCP) as an authenticated tool-access gate. Attendees will leave with a practical framework for bringing participative, secure architectural governance into modern, AI-augmented engineering organizations.
What you will learn:
- Decentralized Governance: Practical patterns for regulating non-human agent behaviors within cross-functional, agile environments.
- Hybrid Topology Design: Strategic criteria for routing agent tasks between local hardware perimeters and public cloud infrastructure based on latency, cost, and compliance.
- Secure Integration Boundaries: Implementing Model Context Protocol (MCP) tools safely as an authenticated interface between models and real environment assets.
From Hackathon to Azure: Building an Agent Factory
Moving an agentic AI prototype into a safety-critical corporate environment uncovers harsh architectural realities far beyond standard code-generation APIs. This experience-driven session pulls back the curtain on the deployment of a 7-phase agentic software orchestrator. We focus entirely on the architectural decisions, failures, and lessons learned when scaling an enterprise-grade agent factory on Microsoft Azure.
We skip the sunny marketing hype to focus on deep technical hurdles: orchestrating state and memory across five specialized agents, handling context window depletion, and balancing local small language models (Phi) with cloud models (Azure OpenAI GPT-4o). Attendees will see exactly how we designed deterministic verification gates to safely contain non-deterministic model actions, alongside a live demonstration of our predictive sprint intelligence engine running 10,000-iteration Monte Carlo simulations.
What you will learn:
- Orchestration Patterns: How to design cloud architecture patterns to coordinate state and token handoffs between specialized AI agents.
- Validation Gate Architecture: Building schema-driven validation layers to catch and verify erroneous LLM outputs before pipeline execution.
- Hybrid Cloud Topology: Structural trade-offs of mapping execution boundaries between local edge hardware and Azure OpenAI gateways.
Code in Motion: Automating Sprints with Multi-Agent Systems
What happens when an AI system handles more than code generation and takes over the orchestration of an entire agile sprint workflow? This session presents a real-world case study of an Agile Sprint Orchestrator designed to handle multi-agent software delivery across a safety-critical engineering domain.We will trace a 7-phase automated multi-agent pipeline spanning backlog refinement, sprint planning, task assignment, execution, verification, and retrospective learning layers. We examine the exact design patterns needed to handle cross-agent handoffs, maintain system observability, and position human-in-the-loop controls where accountability matters most. Developers and architects will leave with an expanded perspective on how multi-agent automation will define developer workflows and team dynamics in 2027 and beyond.
- Takeaways:
- Pipeline Orchestration: Design patterns for syncing, state management, and reliable handoffs between distinct agent roles.
- Human-in-the-Loop Placement: Identifying the exact architectural boundaries where human validation must override autonomous systems.
- Sprint Automation Telemetry: Implementing logging and auditing setups to monitor autonomous actions across software repositories.
Building Production-Ready Agentic Pipelines with MCP and Local LLMs
Step away from theoretical slides and build a functional, multi-agent development engine from scratch. In this intensive, full-day hands-on workshop, participants will engineer a multi-phase agentic workflow capable of parsing task requirements, executing local development steps, and performing automated code verification.We will start by configuring a hybrid local/cloud baseline using Phi via Ollama and Azure OpenAI. From there, we will spend the day writing custom Model Context Protocol (MCP) servers, implementing secure tool interfaces for code execution, and designing deterministic verification gates to constrain non-deterministic model outputs. To maximize coding time and bypass configuration friction, attendees will utilize a prepared GitHub repository with independent code branches for every milestone step.
Takeaways:
- Hybrid AI Environments: Standing up unified developer environments that coordinate local hardware models with cloud endpoints.
- Custom MCP Development: Coding production-grade Model Context Protocol tools to integrate LLMs directly into VS Code workflows.
- State & Guardrail Engineering: Building custom state managers and validation guardrails to securely orchestrate multi-agent actions on real file systems.
Architecting Multi-Agent Pipelines in the Enterprise
While AI coding assistants accelerate individual developers, engineering an autonomous multi-agent factory across an entire team's delivery workflow uncovers severe architectural friction. Moving past basic prompt generation requires robust state management, reliable cross-agent handoffs, and deterministic validation layers built on top of resilient cloud infrastructure.
In this highly technical session, we dissect the implementation of a 7-phase agentic software orchestrator engineered for safety-critical corporate environments. We look at the universal architectural patterns required to handle complex multi-agent state coordination, manage context window depletion, and balance lightweight local small language models (Phi via Ollama) with cloud engines (Azure OpenAI). Developers and architects will walk away with a practical architectural blueprint for utilizing deterministic validation gates to safely contain non-deterministic LLM behavior within production pipelines.
What you will learn:
- Orchestration Patterns: Designing resilient cloud backend layers to coordinate state and token handoffs between specialized AI agents.
- Deterministic Validation: Implementing schema-driven validation gates to securely intercept and verify non-deterministic AI outputs.
- Hybrid AI Infrastructure: Trade-offs and routing mechanics of splitting execution boundaries between local hardware and cloud APIs.
Local vs Cloud AI: The Enterprise Architectural Split
When deploying agentic workflows into production, engineers face a critical crossroads: the speed and privacy of local execution versus the sheer reasoning capability of massive cloud models. This fast-paced lightning talk breaks down the exact technical, economic, and security boundaries that govern where local small language models (SLMs) end and cloud engines must take over. Using concrete engineering implementations with local infrastructure (Phi via Ollama) and cloud environments (Azure), we dissect the hidden trade-offs of this architectural split. We skip the industry hype to analyze cold, hard production realities: context window limitations, processing latency, operational compute costs, and strict enterprise data governance boundaries. Attendees will walk away with a clear, production-tested decision matrix for balancing local and cloud AI in their own engineering pipelines.
Key Take aways from this session:
•The Capability Gap: Identifying when local SLMs are sufficient and where cloud intelligence is required.
• Latency & Cost Analytics: A raw performance comparison of local execution versus cloud API round-trips.
• Data Boundaries: Architecting compliance-safe data perimeters between public cloud models and internal source code.
From Hackathon Win to Enterprise Agentic Reality
Moving an agentic AI prototype into a safety-critical enterprise environment uncovers harsh engineering realities beyond simple code generation.
In this session, we dissect a multi-agent agile orchestrator to explore five architectural reality checks encountered during its evolution.
We will look at why more agents do not equal more autonomy, how we balanced local models (Phi via Ollama) with cloud architectures (Azure GPT6), and how Model Context Protocol (MCP) became our core integration boundary in VS Code.
Attendees will see a live demonstration of a 7-phase agentic pipeline spanning backlog refinement to verification. We skip the hype to focus purely on the deterministic validation gates, security boundaries, and human-in-the-loop controls required when non-deterministic AI meets enterprise compliance.
From Hackathon Win to Enterprise Reality: What Broke When We Engineered an Agentic Software Factory
We won the hackathon. Then the real engineering started.
AI coding assistants can accelerate individual developers. But when AI is introduced across an engineering workflow, the hard problems quickly move beyond code generation: fragmented context, unreliable handoffs, non-deterministic decisions, verification gaps, integration constraints, and the question of where humans must remain accountable.
In this practitioner session, we share our journey from an award-winning agentic AI prototype toward enterprise implementation in a safety-critical automotive engineering environment.
Our Agile Sprint Orchestrator won the Microsoft Reactor Hackathon in the Agentic System Architecture category. Rather than present it as a finished product, we use it as a concrete engineering case study: a 7-phase, multi-agent workflow spanning backlog refinement, sprint planning, task assignment, development workflows, verification, retrospective learning, and sprint intelligence.
The most valuable lessons emerged after the hackathon.
We will show five reality checks that changed how we approached the architecture:
• More agents did not automatically mean more autonomy. We examine the trade-offs of decomposing software delivery into specialized agents, managing state and context, and coordinating handoffs across a multi-agent pipeline.
• LLM output could not become the source of truth. We show where deterministic rules, validation gates, and human-in-the-loop controls became necessary to constrain and verify non-deterministic AI behavior.
• A working prototype was not an enterprise architecture. We discuss what changed when security, compliance, integration, operational, and organizational constraints entered the design — and which assumptions required rethinking.
• MCP became an integration boundary, not just a tool interface. We demonstrate how Model Context Protocol tools exposed orchestrator capabilities to developer workflows through VS Code and Claude Desktop, and the engineering considerations that followed.
• A successful demo was not the finish line. We share what we can demonstrate today, what required architectural evolution, what remains open, and what we learned about the gap between an effective prototype and an architecture suitable for broader enterprise adoption.
We will also explain how we drew the boundary between local and cloud AI using Phi/Ollama and Azure GPT-4o as concrete examples, considering capability, data boundaries, latency, cost, and enterprise constraints.
The session includes a live demonstration of the orchestrator and its MCP-based developer workflow.
Attendees will leave with a practical blueprint for decomposing software-engineering workflows into agents, designing verification boundaries, integrating MCP-based tooling, and evaluating agentic systems beyond the "it works in a demo" stage.
The goal is not to present a perfect success story. It is to share the engineering lessons from the transition — from a hackathon-winning prototype toward enterprise reality — and the decisions we would make differently today.
Although our work comes from automotive engineering, the architectural challenges apply broadly to enterprises introducing agentic AI into software-development workflows.
Live system: https://agile-sprint-orchestrator-h9ks.vercel.app/
Cyber AI & Automation Summit 2026 Sessionize Event Upcoming
Sneha Sankaran
Automotive Software Product Owner & AI Practitioner, Bosch | Agentic AI | MCP | Safety-Critical Engineering
Coimbatore, India
Links
Actions
Please note that Sessionize is not responsible for the accuracy or validity of the data provided by speakers. If you suspect this profile to be fake or spam, please let us know.
Jump to top