This article demonstrates how to re-architect a legacy multi-tenant system for AI-driven features without breaking existing integrations. It highlights the importance of backward compatibility, performance optimization via CDNs, and using AI tools to accelerate developer velocity.
By Andy Shah, Jeremy Klukan, Ben Drasin, Nikhil Pachpande, and Stuart Clark.
In our Engineering Energizers Q&A series, we highlight the engineering minds driving innovation across Salesforce. This edition features Andy Shah, Director of Software Engineering, who leads the development of Agentforce Enhanced Chat, a core customer-facing surface that brings Agentforce capabilities to the consumer web.
Explore how the team built a net new agent-first web experience, re-architecting the system from the ground up, while allowing for easy migration for current production customers and removing developer friction to enable faster iteration.
We enable rich Agentforce experiences for the consumer web. This involves seamlessly embedding new Agentforce capabilities into customer web properties with comprehensive tools and APIs that create native agent experiences with their existing website ecosystem. This enables intelligent interactions that elevate brand engagement. We design systems to allow Agentforce to evolve independently, avoiding disruptive changes while delivering out-of-the-box customizations that accelerate customer time-to-market through seamless, low code integration.
Agentforce Enhanced Chat (aka Enhanced Chat v2) is a fresh take on an agent first consumer facing UX; which also integrates with long-standing production infrastructure that thousands of tenants rely on daily, a fact that fundamentally shapes our development approach. To enable smooth customer adoption of our enhanced interface, we’ve made backward compatibility a foundational engineering principle — ensuring existing implementations remain stable while providing clear upgrade paths. Our goal is to balance innovation with stability – pushing the boundaries of web experiences through thoughtful architectural design and disciplined rollout strategies that bring our entire customer base forward together.
Building Agentforce Enhanced Chat presented a unique architectural balancing act. We wanted to leverage Lightning Types, Lightning Web Components, Service Cloud Realtime backend stack — technologies our customers already know and trust — while introducing a product designed with extensive customization options out of the box and optimized for responsive, high-performance experiences on customer websites.
The product also needed to allow for personalized agentic experiences, adding another layer of complexity to our design decisions. This required a blended strategy: we reused existing components wherever possible but restyled them to meet the demands of our new use case, all without introducing breaking changes that could disrupt backwards compatibility.
We also embraced modern paradigms like centralized state management to accelerate development velocity. However, perhaps the trickiest challenge was ensuring our new architecture could coexist seamlessly with legacy behavior. We needed an easy migration path that scaled gracefully across a vast array of tenant configurations, custom workflows, and diverse traffic patterns — without requiring downtime or synchronized upgrades. Ultimately, making the right architectural investments positioned us for long-term growth, even when those decisions were difficult to prioritize against tight deadlines.
It represents a significant leap forward from its predecessor. The most immediately visible improvement is a polished, modern UI with sub-second load times once the user clicks. There is also far greater potential for branding and customization, allowing businesses to craft chat experiences that truly reflect their identity.
Under the hood, we leverage Lightning Types to deliver rich, dynamic chat experiences that are highly configurable and adaptable to diverse use cases. We also pre-package custom components and load the experience on page load from CDNs to deliver the responsive performance expected of consumer websites.
Through deeper site integration, Agentforce Enhanced Chat introduces context-aware intelligence: agents now understand user intent and journey in real-time, delivering responses that are both accurate and genuinely personalized.
Perhaps most importantly, Agentforce Enhanced Chat is built on modern frameworks designed to evolve and scale for future needs. While v1 continues to serve its purpose well, this new feature was architected with extensibility in mind, ensuring that as customer expectations grow and new capabilities emerge, the platform can adapt without requiring a complete overhaul. It’s not just an upgrade — it’s a foundation for what’s next.
AI tools helped engineers get up-to-speed on Lightning and learn a new codebase quickly. This mattered considerably when writing on top of a live, multi-tenant system where regressions can be very costly.
On the tooling side, we kept the blast radius small. While this is a strong production-ready stack, we were able to isolate just the client code and build a local developer scaffold to iterate quickly. AI helped write a lightweight diagnostic panel so developers could validate behavior quickly without waiting on platform deploy cycles.
That balance was key: leverage a modern developer experience to move fast, but ship changes in a way that remain compatible with existing tenants and doesn’t break long-lived production paths.
Safe migration at the scale of 3,000 live tenants came down to two things: a one-click switch and customer choice, backed by rigorous engineering. We leveraged AI tooling to build one-click upgrade/downgrade with a significant amount of backward-compatible code so tenants could move forward (or roll back) without bespoke solutions. To ensure safety, we leaned hard on unit and functional tests, maintaining high levels of code coverage even while pressed for time.
An embedded application isn’t just the component hosted in an iframe; it also necessarily includes some script (however small) hard-coded into the customer’s page, plus an embedding script dynamically loaded into the customer’s page to create and manage the iframe. The script written into the customer’s page can’t change for the upgrade – requiring the customer to update their web page introduces too much friction both for deployment and rollback if necessary. The embedding script is different between v1 and Agentforce Enhanced Chat, it’s important that we avoid version mismatches between the embedding script and the chat UI itself, so version upgrade/downgrade for both has to be managed in a single publish action.
It’s important that customers control the elements of their web property. To support this, we designed a preview and publish system that allows customers to choose their own migration path and timing. Because migrations are self-initiated, the system must respect every migration as a production event, with deterministic behavior and a clear rollback strategy across versions.
Agentforce Enhanced Chat preview and publish system architecture.
Agentforce Enhanced Chat established a foundation to help us evolve independently of legacy constraints. With clear compatibility boundaries in place, we can introduce new agent-driven capabilities giving customers complete control of when they feel comfortable to migrate.
The architectural patterns developed as part of the initiative — incremental rollout, compatibility enforcement, and developer-centric tooling—are also applicable to other Agentforce integrations. As the platform expands, these patterns provide a repeatable model for safely operationalizing new capabilities in production environments.
Most importantly, this work proved we can modernize core customer-facing systems while enabling seamless testing and effortless migration for our customers. We preserved reliability and developer velocity. That confidence shapes how we approach future Agentforce investments across the platform.
The post How Agentforce Enhanced Chat Built an Agent-first Chat Experience While Ensuring Easy Migration for 3,000+ Customers appeared first on Salesforce Engineering Blog.
Continue reading on the original blog to support the author
Read full articleThis approach demonstrates how to scale LLM-driven automation by replacing black-box fine-tuning with deterministic DSLs. It ensures reliability and debuggability for mission-critical workflows while significantly reducing the operational overhead of model maintenance.
This architecture solves the statelessness problem in AI agents, enabling long-term context and reliability at scale. It provides a blueprint for building governable, auditable AI systems that maintain user trust while reducing prompt noise and latency through structured memory layers.
This shift moves beyond AI wrappers to fundamental architectural changes. It enables software to handle edge cases and cross-domain coordination autonomously, reducing the need for human intervention while maintaining reliability through governed action contracts.
This article details the architectural shift from fragmented point solutions to a unified AI stack. It provides a blueprint for solving data consistency and metadata scaling challenges, essential for engineers building reliable, real-time agentic systems at enterprise scale.
