AlexSablan.info

Interactive Media Designer and SalesForce Commerce Cloud Developer

Anime illustration of a developer and AI assistant reviewing an ecommerce storefront beneath the heading SFCC + Agentforce.
Salesforce Commerce Cloud

SFCC and Agentforce: What Developers and Architects Need to Know

The opportunities, challenges, and architectural considerations behind Salesforce’s move toward agentic commerce.

Salesforce has been pushing Agentforce pretty heavily, and with the latest Commerce Cloud releases, it’s becoming clear that AI is going to play a much larger role in how we build and manage eCommerce storefronts.

For anyone working with Salesforce Commerce Cloud (SFCC), particularly B2C Commerce, this raises some interesting questions.

What does Agentforce actually bring to the platform? How much of it can we use with existing SFRA and PWA Kit implementations? And perhaps more importantly, does it simplify development, or are we introducing another layer of complexity into an already complicated architecture?

I’ve spent a good portion of my career working with SFCC and enterprise eCommerce integrations. One thing I’ve learned is that new technology is rarely as simple to implement as the initial demonstrations make it look.

Agentforce has some legitimate advantages, especially around product discovery, customer service, and development automation. But there are also technical limitations, integration dependencies, and architectural decisions that deserve attention before committing to it.

What Is Agentforce for Salesforce Commerce Cloud?

Anime illustration of a developer and AI assistant reviewing connected ecommerce, cloud, database, and security symbols.
Thoughtful commerce integration planning

Agentforce is Salesforce’s platform for building AI agents that can interact with customers, retrieve information, and perform actions through connected Salesforce systems.

For B2C Commerce, the most visible application is the Shopper Agent, which allows customers to interact with a storefront conversationally rather than relying entirely on traditional navigation and search.

Instead of searching for a product, filtering through results, and comparing individual PDPs, a customer might ask:

“I’m looking for a beginner RC airplane that’s easy to fly, includes everything I need, and costs less than $300.”

An appropriately configured shopping agent could use product information and search capabilities to identify suitable products, ask follow-up questions, and help the customer add something to their cart.

That’s a meaningful improvement over traditional keyword-based search when the customer doesn’t know exactly what they’re looking for.

But Agentforce Commerce goes beyond customer-facing conversations.

Salesforce is also introducing AI-assisted development tools, administrative automation, new storefront architecture options, and integrations that allow external AI applications to interact with commerce services.

These capabilities aren’t all the same product, and they shouldn’t be evaluated as though they are.

What Salesforce Actually Released in 2026

Salesforce made several significant announcements throughout 2026. Some are already generally available, while others have specific licensing requirements, limitations, or rollout considerations.

January 2026: More Capabilities for the B2C Shopping Agent

The B2C Commerce 26.1 release expanded how customers can access the shopping agent within SFRA storefronts.

Salesforce introduced additional launch locations, including the site header, search suggestions, and a floating icon.

The release also included guided product discovery and support for manually applying coupons.

These might sound like relatively small improvements, but they address two areas where conversational commerce needs to work well: helping customers find products and keeping the cart experience consistent with the storefront.

Source: Salesforce B2C Commerce 26.1 Release Notes

June 2026: Agentforce Commerce Expands

The June release was a much larger change.

Salesforce announced general availability of its Shopper Agent, Buyer Agent, and Merchant Agent, along with the introduction of Agentic Commerce Search.

It also launched Storefront Next and expanded its Commerce Apps framework.

For developers, one of the more interesting additions was the Agentic B2C Developer Toolkit, which introduced tools for working with commerce environments using AI coding assistants.

Salesforce also announced improvements to SCAPI, observability, and storefront development workflows.

Source: Salesforce June 2026 B2C Commerce Release

September 2026: AI Development Becomes More Practical

The September release brought several improvements that are particularly relevant to development teams.

The Agentic B2C Developer Toolkit 2.0 became available on September 15, 2026, adding support for MCP-based development workflows, CLI operations, and AI-assisted administration.

Salesforce also introduced Commerce Vibes, an AI-assisted development environment for SFRA, PWA Kit, and Storefront Next.

The important distinction here is that developers aren’t necessarily required to abandon their existing coding tools.

Salesforce’s toolkit supports assistants such as Codex, Claude, Cursor, and other compatible environments.

That flexibility matters. Most development teams already have established IDEs, repositories, CI/CD pipelines, and code review processes.

Source: Salesforce Agentic B2C Developer Toolkit Release Notes

The Advantages of Agentforce for SFCC Developers

1. Better Product Discovery

Traditional SFCC search depends heavily on catalog structure, searchable attributes, synonyms, refinement definitions, and the quality of the product feed.

When everything is configured correctly, it works well.

But customers don’t always search using the terminology stored in the catalog.

A customer might search for “a replacement wing for my plane” without knowing the manufacturer, model number, or compatible part number.

Conversational product discovery creates an opportunity to narrow those results by asking questions rather than expecting customers to understand the catalog.

This could be particularly valuable for retailers with large catalogs, complicated product relationships, or highly technical products.

There is a catch, though.

The agent still needs accurate product data.

If compatibility information isn’t represented correctly in the catalog or accessible through a trusted integration, the agent can’t reliably determine which replacement part fits which product.

AI doesn’t eliminate the need for good product data. If anything, it makes accurate product relationships more important.

2. Faster Development and Troubleshooting

The Agentic B2C Developer Toolkit is probably one of the more immediately useful developments for SFCC developers.

According to Salesforce’s documentation, the toolkit supports operations such as deploying cartridges, managing code versions, running jobs, configuring environments, investigating logs, and working with SCAPI.

Those are real development tasks that normally require moving between an IDE, Business Manager, command-line tools, and other administrative interfaces.

Being able to work through some of those operations from an AI-assisted development environment could save time.

For example, imagine investigating a custom SCAPI endpoint that works locally but fails in a sandbox.

Instead of manually checking every configuration, an appropriately authorized assistant could help inspect the endpoint implementation, relevant permissions, environment settings, and available logs.

That doesn’t mean the agent will automatically find the issue.

But reducing the time spent gathering information and switching between tools would be valuable.

The biggest advantage may not be AI writing more code. It may be AI helping developers understand existing code and environments faster.

3. A More Flexible Customer Experience

The Shopper Agent also creates opportunities beyond basic product search.

Customers could potentially ask about product availability, promotions, order status, or delivery options without navigating several different pages.

For enterprise storefronts, this could reduce some of the friction associated with complex shopping journeys.

It could also reduce the number of routine questions reaching customer service teams.

However, those benefits depend on the agent having access to accurate information and the correct actions.

A conversational interface doesn’t automatically mean the underlying services are connected.

4. Support for Existing Storefront Architectures

One positive aspect of Salesforce’s approach is that the Shopper Agent isn’t limited to Storefront Next.

Salesforce documents implementations for SFRA and PWA Kit as well.

For SFRA, the Agentforce Commerce Client uses a cartridge and Business Manager configuration.

For PWA Kit, Salesforce documents configuration through Managed Runtime environment variables.

That provides an adoption path for organizations that aren’t planning to replace their existing storefront architecture.

This is important because most established SFCC implementations have years of customizations, integrations, and business-specific logic.

Moving to a new storefront framework just to introduce an AI shopping experience would be difficult to justify.

The Disadvantages and Architectural Concerns

This is where I think developers and architects need to spend more time.

The demonstrations are interesting, but the real questions start when Agentforce needs to interact with an existing enterprise commerce environment.

1. Integration Complexity Doesn’t Disappear

A typical enterprise SFCC implementation doesn’t operate independently.

Product data may originate in an ERP or PIM. Inventory might come from a separate system. Order management, shipping, payments, loyalty, fraud prevention, and customer service may all depend on different integrations.

Agentforce introduces another consumer of that information.

Consider a customer asking:

“Can I cancel my order before it ships?”

That sounds like a straightforward request.

But answering it correctly might require checking the order status in SFCC, retrieving fulfillment information from an order management system, verifying cancellation eligibility, and determining whether the fulfillment process can still be stopped.

The agent shouldn’t make that decision based solely on the information available in the storefront.

It needs access to the system that actually controls the cancellation.

For architects, this means defining which system owns each operation and how the agent is permitted to interact with it.

Agentforce doesn’t replace those integrations. It depends on them.

2. Custom Business Logic Is a Major Consideration

Most enterprise SFCC implementations contain custom business rules that go well beyond the standard storefront functionality.

Examples include:

  • Product eligibility and compatibility rules
  • Customer-specific pricing and promotions
  • Inventory allocation and backorder handling
  • Return and cancellation restrictions
  • Loyalty and gift certificate integrations
  • Shipping restrictions and delivery calculations

If an agent is going to perform an action, it needs to follow the same rules as the storefront.

The last thing you want is a customer receiving one answer from the shopping agent and a different answer when they reach checkout.

This is especially important for promotions, inventory, and order modifications.

My preference would be to keep business rules in the services that already own them and expose controlled operations to the agent.

I wouldn’t want to duplicate important business logic inside prompts or agent configuration.

That creates two places to maintain the same rules, and eventually those implementations will drift apart.

3. Security and Permissions Become More Important

Giving an AI agent access to commerce operations introduces security questions that go beyond a traditional chatbot.

There’s a significant difference between allowing an agent to explain a return policy and allowing it to initiate a return or modify an order.

The second requires authentication, authorization, validation, and auditability.

For example, an agent should never be able to retrieve another customer’s order simply because someone provides a valid order number.

It also shouldn’t be able to bypass eligibility rules or execute privileged operations using credentials that provide more access than the customer should have.

Developers need to consider how identity, session context, API permissions, and customer authorization are enforced.

Salesforce provides platform security and trust capabilities, but those features don’t remove the responsibility to secure custom integrations.

4. Troubleshooting Gets More Complicated

Traditional storefront issues are usually investigated through application logs, network requests, API responses, and the relevant source code.

Agent-driven workflows add another dimension.

An agent may interpret a request, select an action, retrieve information from multiple systems, and generate a response.

When something goes wrong, developers need to determine whether the problem originated in the agent’s interpretation, the selected action, the API response, or the underlying business logic.

Imagine an agent telling a customer that an item is available when the PDP says it’s out of stock.

Where do you start?

You need to know which inventory source the agent queried, when the information was retrieved, whether caching was involved, and how the response was generated.

Without sufficient tracing and observability, diagnosing these issues could become difficult.

Salesforce has been expanding its logging and tracing capabilities, but architects still need to design observability across their own integration boundaries.

5. Cost and Operational Overhead

AI services introduce additional costs that need to be evaluated against actual business value.

Licensing, consumption, implementation, testing, monitoring, and ongoing maintenance all contribute to the total cost.

There’s also the question of whether the agent is actually improving the customer experience.

If customers use the agent to find products faster, complete more purchases, or resolve routine questions without contacting support, the investment may be worthwhile.

But if most customers continue using traditional navigation and search, the return becomes harder to justify.

I would want to see measurable improvements before expanding the implementation across every customer journey.

SFRA vs. PWA Kit: Does Agentforce Change the Architecture Decision?

I don’t think Agentforce alone is a reason to move from SFRA to PWA Kit or Storefront Next.

Each architecture already has its own advantages, limitations, and maintenance considerations.

Agentforce adds capabilities, but it doesn’t automatically change the underlying business requirements.

SFRA

For SFRA implementations, Salesforce provides the plugin_commerce_client cartridge.

That makes it possible to introduce the Shopper Agent without rebuilding the storefront.

The primary concerns are how the client interacts with existing customizations, whether it affects storefront performance, and how it integrates with existing customer and cart workflows.

PWA Kit and Managed Runtime

PWA Kit uses a different implementation model.

Salesforce documents the COMMERCE_AGENT_SETTINGS environment variable for configuring the Agentforce Commerce Client in Managed Runtime.

This approach fits naturally with environment-based configuration, but developers still need to validate how the client behaves with custom React components, application state, routing, and existing API integrations.

For heavily customized PWA storefronts, I would specifically test interactions with cart state, authentication, navigation, and server-side rendering.

Storefront Next

Storefront Next introduces another option for organizations evaluating new implementations.

Salesforce is clearly investing in this architecture, including Commerce Apps and additional development tooling.

For a new storefront, it deserves consideration.

For an established storefront, though, a migration still needs to be justified by business requirements, implementation cost, maintainability, and long-term platform strategy.

I wouldn’t recommend a migration based on Agentforce availability alone.

The Bigger Architectural Question: Who Owns the Business Logic?

For me, this is one of the most important considerations.

Agentforce should be an interface to trusted commerce capabilities, not an independent implementation of commerce rules.

If a customer asks whether an item can be returned, the agent should retrieve eligibility from the appropriate service.

If a customer asks about inventory, it should use the inventory source that the storefront trusts.

If a customer wants to cancel an order, the cancellation needs to go through the same validated workflow used by the rest of the application.

That means architects need clearly defined API contracts, system ownership, and authorization boundaries.

A well-designed implementation allows multiple consumers, including storefronts, mobile applications, and AI agents, to use the same underlying business capabilities.

A poorly designed implementation creates separate logic for each channel.

We’ve spent years trying to avoid that problem in enterprise eCommerce. We shouldn’t reintroduce it because the new interface happens to be conversational.

What About AI Coding Agents for SFCC Development?

I see a more immediate opportunity here than in some of the customer-facing features.

Tools such as Codex, GitHub Copilot, Claude, and Salesforce Commerce Vibes can help developers investigate unfamiliar code, generate tests, identify integration dependencies, and automate repetitive tasks.

Salesforce’s MCP-based developer toolkit makes that more interesting because it provides commerce-specific capabilities rather than relying entirely on an AI assistant’s general knowledge.

But I would still be cautious about giving an autonomous agent unrestricted access to environments.

There’s a big difference between asking an assistant to investigate a failed job and allowing it to modify job configurations or execute deployments.

I would start with read-only access, explicit approval for changes, and clear environment restrictions.

Code review, automated testing, and deployment controls should remain part of the development process.

AI-generated code still needs to meet the same standards as code written by a developer.

And in an enterprise SFCC implementation, understanding why a change is correct is just as important as getting it to work.

What I Would Test Before Introducing Agentforce

If I were evaluating Agentforce for an existing SFCC storefront, I would start with a limited proof of concept rather than a broad rollout.

First, I would test product discovery.

Choose a category where customers frequently struggle to find the right product. Measure whether conversational search improves discovery compared with existing storefront search.

Next, I would validate the underlying data.

Check how the agent handles missing attributes, incorrect compatibility information, unavailable products, and differences between indexed catalog data and real-time inventory.

Then, I would test business rules and integrations.

Make sure pricing, promotions, shipping, inventory, and order operations produce results consistent with the existing storefront.

I would also test security and failure handling.

What happens when an API times out? What happens when an authenticated session expires? Can the agent recover without giving the customer incorrect information?

Finally, I would measure performance and business impact.

That includes storefront performance, API traffic, latency, conversion, customer engagement, support deflection, and the operational cost of running the agent.

If those results demonstrate a clear benefit, expanding the implementation makes sense.

If they don’t, I’d rather know that from a controlled POC than after introducing another major dependency into production.

Is Agentforce Worth It for Salesforce Commerce Cloud?

I think Agentforce has real potential, but I wouldn’t treat it as something every SFCC implementation needs immediately.

For developers, the AI-assisted tooling may deliver value sooner by reducing repetitive work and making existing systems easier to investigate.

For merchants, conversational product discovery could improve the shopping experience, especially when products require additional explanation or have complicated relationships.

For architects, the challenge is making sure those capabilities work within the existing commerce architecture rather than creating another set of disconnected services.

Salesforce is investing heavily in agentic commerce, and the 2026 releases show that this is becoming a significant part of the platform’s direction.

But the fundamentals of good eCommerce architecture haven’t changed.

We still need accurate data, reliable integrations, clear system ownership, secure APIs, consistent business rules, and proper observability.

Agentforce can make those capabilities easier for customers and developers to use.

It can’t compensate for not having them.

My takeaway is pretty simple: I’d absolutely evaluate Agentforce, particularly the developer tooling and product discovery capabilities. But I’d want a working POC, measurable results, and a clear understanding of the integration requirements before recommending a broader implementation.

That’s probably less exciting than some of the demonstrations, but it’s how I’d approach it on a real enterprise storefront.


References and Further Reading

The following Salesforce documentation and release announcements informed this article:

  1. Salesforce: Agentforce Commerce June 2026 Announcement
  2. Salesforce: B2C Commerce June 2026 Release
  3. Salesforce: B2C Commerce 26.1 Release Notes
  4. Salesforce: Agentic B2C Developer Toolkit Release Notes
  5. Salesforce Developers: Agentforce Commerce Vibes Overview
  6. Salesforce Developers: Install Agentforce Commerce Client on SFRA
  7. Salesforce Developers: Install Agentforce Commerce Client on PWA Kit
  8. Salesforce Help: Shopper Agent for B2C Commerce

About the author: Alex Sablan is an eCommerce Technical Lead at Horizon Hobby with experience in Salesforce B2C Commerce, SFRA, PWA Kit, enterprise integrations, and eCommerce architecture.

LEAVE A RESPONSE

Your email address will not be published. Required fields are marked *

This site uses Akismet to reduce spam. Learn how your comment data is processed.