The advent of AI agents is widely discussed as a transformative force in application development, with much of the focus on the automation that generative AI brings to the process. This shift is expected to significantly reduce the time and effort required for tasks such as coding, testing, deployment, and monitoring. However, what is even more intriguing is the change not just in how applications are built, but in what is being built. This perspective was highlighted during last week’s Salesforce developer conference, TDX25. Developers are no longer required to build entire applications from scratch. Instead, they can focus on creating modular building blocks and guidelines, allowing AI agents to dynamically assemble these components at runtime. In a pre-briefing for the event, Alice Steinglass, EVP and GM of Salesforce Platform, outlined this new approach. She explained that with AI agents, development is broken down into smaller, more manageable chunks. The agent dynamically composes these pieces at runtime, making individual instructions smaller and easier to test. This approach also introduces greater flexibility, as agents can interpret instructions based on policy documents rather than relying on rigid if-then statements. Steinglass elaborated: “With agents, I’m actually doing it differently. I’m breaking it down into smaller chunks and saying, ‘Hey, here’s what I want to do in this scenario, here’s what I want to do in this scenario.’ And then the agent, at runtime, is able to dynamically compose these individual pieces together, which means the individual instructions are much smaller. That makes it easier to test. It also means I can bring in more flexibility and understanding so my agent can interpret some of those instructions. I could have a policy document that explains them instead of hard coding them with if-then statements.” During a follow-up conversation, Steinglass further explored the practical implications of this shift. She acknowledged that adapting to this new paradigm would be a significant change for developers, comparable to the transition from web to mobile applications. However, she emphasized that the transition would be gradual, with stepping stones along the way. She noted: “It’s a sea change in the way we build applications. I don’t think it’s going to happen all at once. People will move over piece by piece, but the result’s going to be a fundamentally different way of building applications.” Different Building Blocks One reason the transition will be gradual is that most AI agents and applications built by enterprises will still incorporate traditional, deterministic functions. What will change is how these existing building blocks are combined with generative AI components. Instead of hard-coding business logic into predetermined steps, AI agents can adapt on-the-fly to new policies, rules, and goals. Steinglass provided an example from customer service: “What AI allows us to do is to break down those processes into components. Some of them will still be deterministic. For example, in a service agent scenario, AI can handle tasks like understanding customer intent and executing flexible actions based on policy documents. However, tasks like issuing a return or connecting to an ERP system will remain deterministic to ensure consistency and compliance.” She also highlighted how deterministic processes are often used for high-compliance tasks, which are automated due to their strict rules and scalability. In contrast, tasks requiring more human thought or frequent changes were previously left unautomated. Now, AI can bridge these gaps by gluing together deterministic and non-deterministic components. In sales, Salesforce’s Sales Development Representative (SDR) agent exemplifies this hybrid approach. The definition of who the SDR contacts is deterministic, based on factors like value or reachability. However, composing the outreach and handling interactions rely on generative AI’s flexibility. Deterministic processes re-enter the picture when moving a prospect from lead to opportunity. Steinglass explained that many enterprise processes follow this pattern, where deterministic inputs trigger workflows that benefit from AI’s adaptability. Connections to Existing Systems The introduction of the Agentforce API last week marked a significant step in enabling connections to existing systems, often through middleware like MuleSoft. This allows agents to act autonomously in response to events or asynchronous triggers, rather than waiting for human input. Many of these interactions will involve deterministic calls to external systems. However, non-deterministic interactions with autonomous agents in other systems require richer protocols to pass sufficient context. Steinglass noted that while some partners are beginning to introduce actions in the AgentExchange marketplace, standardized protocols like Anthropic’s Model Context Protocol (MCP) are still evolving. She commented: “I think there are pieces that will go through APIs and events, similar to how handoffs between systems work today. But there’s also a need for richer agent-to-agent communication. MuleSoft has already built out AI support for the Model Context Protocol, and we’re working with partners to evolve these protocols further.” She emphasized that even as richer communication protocols emerge, they will coexist with traditional deterministic calls. For example, some interactions will require synchronous, context-rich communication, while others will resemble API calls, where an agent simply requests a task to be completed without sharing extensive context. Agent Maturity Map To help organizations adapt to these new ways of building applications, Salesforce uses an agent maturity map. The first stage involves building a simple knowledge agent capable of answering questions relevant to the organization’s context. The next stage is enabling the agent to take actions, transitioning from an AI Q&A bot to a true agentic capability. Over time, organizations can develop standalone agents capable of taking multiple actions across the organization and eventually orchestrate a digital workforce of multiple agents. Steinglass explained: “Step one is ensuring the agent can answer questions about my data with my information. Step two is enabling it to take an action, starting with one action and moving to multiple actions. Step three involves taking actions outside the organization and leveraging different capabilities, eventually leading to a coordinated, multi-agent digital workforce.” Salesforce’s low-code tooling and comprehensive DevSecOps toolkit provide a significant advantage in this journey. Steinglass highlighted that Salesforce’s low-code approach allows business owners to build processes and workflows,
