The independent daily for Salesforce admins, developers and architects

Curated by Abhinav (opens in a new tab)

Recommended

Two VS Code extensions bring visual context back to agent-driven Salesforce work (opens in a new tab)

You will learn what the Metadata Visualizer and Live Preview VS Code extensions show, which metadata types and UI bundles they cover, and how to open them.

Why read this

It helps you judge whether they fit a workflow built on agents and the Headless Toolkit.

Setup and XML route

  • Retrieve long XML file
  • Navigate Setup to change permissions
  • Retrieve updated metadata
  • Commit changes to version control

Headless Toolkit route

  • Query and modify from terminal
  • Edit metadata locally
  • No retrieve after changes
  • Run operations in parallel
Editing a Permission Set with and without the Headless Toolkit

Building with agents lets developers skip many Setup clicks, but it removes the visual context that makes Flows and Permission Sets easy to grasp. The post presents two VS Code extensions, Metadata Visualizer and Live Preview, as a way to restore that context. It frames them as the visual companion to the Headless Toolkit, which combines agent skills, hosted MCP servers and the Headless Experience Layer.

The author describes the Headless Toolkit through a Permission Set example. Working through Setup meant retrieving a long XML file, navigating menus to understand and change permissions, then retrieving and committing the result. Through agents and the toolkit, the same change can be queried and edited from the terminal in seconds, locally and in parallel, without repeated round trips.

Metadata Visualizer renders read-only views of Salesforce metadata and comes with the Salesforce Extension Pack for VS Code. It covers agents, Flows, Lightning pages, objects and Permission Sets as of November 2026, and is opened by clicking Visualize in the editor. Users can analyze in the visualizer and ask an agent to apply changes, and with Agentforce Vibes they can select elements to have the agent edit them. Live Preview covers Lightning Web Components and Multi-Framework UI bundles, using live org data, and HXL widgets, using sample data that can be customized as JSON.

The post closes by suggesting that future interactive widgets could show metadata directly in agent responses, replacing some of these extensions and builders.

Read the original at Salesforce Developers Blog (opens in a new tab)

Worth reading?

Recommended

AIforce exposes Salesforce configuration to outside agents through MCP and the Headless Toolkit (opens in a new tab)

You will learn what AIforce and the Headless Toolkit expose from your org, the five tools that make it up, and how the security model applies to agents acting as users.

Why read this

You will also see what admins should review before opening the org to external agents.

Headless Toolkit

  • MCP servers
  • APIs
  • Skills
  • Plugins
  • Developer tools
The Headless Toolkit has five parts that expose org configuration outward

Salesforce’s AIforce strategy lets people work with Salesforce from the tools they already use, such as Slack, Claude and other AI clients, rather than only from the Salesforce UI. The article places AIforce as the interface layer above Data 360, Customer 360 and Agentforce. It stresses that the Lightning UI, Reports and Dashboards are not going away.

The Headless Toolkit, formerly called Headless 360, is the set of technologies that makes this work. It has five parts: MCP servers, which use OAuth and may be Salesforce-hosted or custom; APIs, including the Agent API and the platform data APIs; skills, which are instruction folders that AI clients load for a task; plugins, which package skills with commands and MCP connections; and developer tools such as the Salesforce CLI, Agentforce Vibes and the declarative Agent Script format. The article says this is an umbrella over existing capabilities rather than a new product, citing 60+ MCP tools, 4,000+ APIs and 220+ CLI commands.

For developers building external applications, there are two routes: the Headless Experience Layer, which renders workflows natively in channels such as Slack, WhatsApp, voice or mobile, or direct calls to the APIs and MCP tools with a custom UI. Either way, the flows, data models and guardrails configured in the org are what they build on.

On security, the article says Sharing Rules, field-level security and Permission Sets are respected however data is accessed, and that calls pass through the Trust Layer. Every call carries identity, access, capability and governance controls, so Validation Rules, triggers and governor limits still apply. Because an agent can do anything the acting user can do, the article advises reviewing profiles and Permission Sets before exposing the org. Agentic Identity, where agents have their own permissions and credentials, is described as planned for the near future.

Read the original at Salesforce Admins Blog (opens in a new tab)

Worth reading?

Must-read

Running a seven-stage agent-driven Salesforce lifecycle with the Headless Toolkit (opens in a new tab)

You will learn how to structure a Salesforce project around coding agents, using Skills, hosted MCP Servers and the Salesforce CLI across seven stages from grounding to observation.

Why read this

You will also see how to keep the agent's context lean and feed each mistake back into the project's instructions, checks and specs.

  1. Ground in business and org
  2. Specify what to build
  3. Build with the agent
  4. Verify with tests and checks
  5. Review with a reviewer agent
  6. Release through a human gate
  7. Observe and feed mistakes back
The seven stages of the agent-driven Salesforce lifecycle, each leaving an artifact for the next

This Salesforce Developers Blog post, written by Principal Developer Advocate Mohith Shrivastava, proposes an agent-driven development lifecycle built on the Headless Toolkit: the Salesforce Skills Library (sf-skills), Salesforce Hosted MCP Servers for org context, and the Salesforce CLI for testing and deploying. The author argues that coding agents drift from platform best practices and miss what already exists in an org, so a team should wrap them in its own project layer of skills, instructions, ontology, tools and checks. The linear project model becomes a loop in which each stage leaves an artifact for the next, and every mistake feeds back into the project. The author also stresses keeping the agent’s context lean, since accuracy falls as the context window fills, and notes that the agent’s built-in harness is the same for everyone while the project harness is what makes it effective on a specific org.

The seven stages run as follows. Ground gives the agent the org’s existing metadata through the read-only Metadata Grounding MCP Server (Beta), a feature map and an ontology of business terms. Specify has the agent produce a short, human-approved spec kept up to date alongside the code, recommended as spec-anchored and used only for features that span several metadata types or sessions. Build lets one agent work step by step, or subagents work in parallel in separate git worktrees, with each subagent given only the context it needs. Verify runs independent checks such as Apex tests, Code Analyzer, ApexGuru scans, LWC and accessibility checks, and hooks that run automatically. Review uses a separate, read-only adversarial reviewer agent whose findings humans judge. Release has the agent validate and promote changes through deterministic gates, with a human owning the production step. Observe has the agent read debug logs and traces to find production issues and start the next loop.

The post closes with a principle: each repeated mistake should become a constraint. Advisory instructions and skills reduce errors, but deterministic tests, Code Analyzer rules, hooks and quality gates catch them regardless of who wrote the code, and the author recommends choosing the strongest option available and cleaning up existing code that the agent might copy. The author presents this as one approach to adapt rather than the only way, and suggests installing the skills and starting with the stages that suit the team.

Read the original at Salesforce Developers Blog (opens in a new tab)

Worth reading?

Recommended

Quick Pages beta lets users build governed single-page views in Salesforce (opens in a new tab)

You will learn what Quick Pages does, how its Permission Sets and read-only beta limits affect your org, and what is planned next.

Why read this

Useful if you plan to let users build their own views.

  1. Describe the page in natural language
  2. Review a live preview as it is built
  3. Share with individuals, groups or the org
How a user builds and shares a Quick Page in the beta

Quick Pages, now in beta, lets users in an org build and share their own single-page apps with charts, data tables, tabs and actions, described in natural language through Agentforce Coworker or the Quick Pages tab. The pages are grounded in the org’s metadata, including Custom Objects and fields, and show a live preview while they are built.

The pages follow the standard Salesforce security model, so users see only the data they can access, and they pull from live data rather than going stale. Building a page does not change the org’s metadata. Admins control access with the “Create and View Quick Pages (Beta)” and “View Quick Pages (Beta)” Permission Sets, and can view and manage every page. The Headless Toolkit applies the same permission checks and data rules whichever client builds the page.

During beta, AI chat is free but will be metered at general availability. Pages built in beta are read-only, so users cannot change records from them yet, and they will remain viewable after general availability. Planned additions include record editing, Apex and Connect REST API data sources, Data 360 support, and a Claude integration.

Read the original at Salesforce Blog (opens in a new tab)

Also told by Salesforce Ben (opens in a new tab)

Worth reading?

AIforce is a separate Layer from Agentforce, and developers shift to design and review (opens in a new tab)

You will learn how the Headless Toolkit and AIforce differ from Agentforce, and how the developer role is shifting toward guidelines, review and guardrails.

Why read this

The piece is a session recap rather than a technical guide.

Headless Toolkit

  • MCP Servers
  • Headless Experience Layer
  • Multi framework support
The Headless Toolkit has three pieces that together open Salesforce to any agent

The author writes that AIforce does not replace Agentforce. Agentforce remains Salesforce’s own AI, while AIforce is the layer that opens Salesforce to any MCP client or agent, together with partnerships with agent vendors. He lists the Headless Toolkit’s parts: MCP Servers that expose business logic to any agent, a Headless Experience Layer that renders interfaces dynamically inside agents, and support for frameworks such as Angular and React alongside Lightning Web Components.

According to Alba Rivas of Salesforce, as cited in the piece, the classic workflow of creating objects, writing queries, classes, tests and deploying has less time left. The developer’s work moves to design (asking an agent for a solution that follows your guidelines), review (checking that output matches the request), and guardrails (giving the agent knowledge and limits). Building an app that works in a production enterprise environment is the hard part.

The piece also notes that the Claude relationship continues with an existing Salesforce plugin, while OpenAI and NVIDIA also appeared on stage. It describes MCP as becoming a universal protocol used by business users too, and skills as Markdown files that can be shared across a team.

Read the original at dev.to (opens in a new tab)

Worth reading?

How Salesforce uses headless patterns internally, and how to apply them (opens in a new tab)

You will learn how Salesforce applies headless architecture to agents, customer-facing experiences and internal tooling, and the three components it considers necessary for a trusted headless agent.

Why read this

You will also see the reported gains from building on Multi-Framework with React.

  1. Ground in business context via Data 360
  2. Interpret requests and act through tools
  3. Build governance in from the start
The three baseline components Salesforce uses to build a trusted headless agent

Salesforce presents its Headless Toolkit and AIforce as a way to bring platform capabilities, security and business context to any surface where work happens, rather than confining them to a single standard UI. The post follows its “Customer Zero” principle and describes four internal uses: an IT support agent that runs in Slack and a self-service portal on the same Flows and governance, a security and access agent that calls tools exposed by the Salesforce MCP server, a Headless Experience Layer playground for building widgets with mock data, and a React app that monitors a 15,000-engineer internal org.

The post says a trusted headless agent needs three baseline components: grounding in business context through Data 360, the ability to interpret requests and act through tools, and governance built in. It also reports that Builder Central’s frontend was rebuilt in React on Multi-Framework in a two-week sprint, where the previous stack would have taken two to three months, and that the development inner loop dropped from minutes of build and sync time to seconds.

Most of the piece is positioning and promotion, and it gives few concrete measurements or code. The architectural pattern of building logic once and exposing it through several surfaces is the useful takeaway for architects, with the timing claims as Salesforce’s own account.

Read the original at Salesforce Blog (opens in a new tab)

Worth reading?

Pronto sample App shows how to build Headless Agentforce experiences (opens in a new tab)

You will see how one sample app wires Agentforce agents, custom MCP servers and HXL widgets together, and which tool types and latency trade-offs to weigh when exposing Salesforce logic to external clients.

  1. Agentforce agents and actions in the org
  2. Hosted MCP Servers expose the tools
  3. External Client App connects the client
  4. Third-party agent renders HXL widgets
How the Pronto employee assistant reaches users across surfaces

The Pronto sample app is an open-source example built on the Headless Toolkit, set around a fictional food delivery platform. It ships two Agentforce agents: an employee assistant and a customer service assistant. Both are orchestrator agents that share a storefront explorer assistant as a connected subagent, which shows how multi-agent orchestration can transfer conversations and reuse subagents without losing context.

The app also demonstrates exposing business logic through Salesforce Hosted MCP Servers. Its employee MCP server offers several tool types: Apex tools built from invocable actions, an Apex REST tool for storefront search registered through the API Catalog, and an Agentforce agent exposed as a custom MCP tool. The article notes that the agent-as-tool adds latency, because Agentforce makes further LLM calls after the first call to the MCP server.

Pronto is delivered to several surfaces from one codebase: an LWR Experience Cloud customer site, and external clients such as Claude, Slack and ChatGPT. Through the Headless Experience Layer Beta, the employee server can return rich HXL widgets, such as an order status card, which render the same way on each surface. Readers can create an External Client App, connect the server to a third-party agent, and deploy the source from GitHub to try it.

Read the original at Salesforce Developers Blog (opens in a new tab)

Worth reading?

Recommended

Salesforce plans agent identities and metered billing for Agentic API calls (opens in a new tab)

You will learn what Agentic Identity and Headless Platform Interactions are, which calls count toward Flex Credits, and when the transition deadlines and production-only billing rules apply.

Why read this

The exact multiplier is still unannounced.

Traditional integrations

  • Existing pricing kept
  • Existing security kept

Registered agents

  • Counted as HPIs
  • Drawn from Flex Credits
Traditional integrations keep existing terms, while agentic interactions move to the new HPI model

Salesforce has described upcoming changes to AIforce and the Headless Toolkit in its help documentation. The main changes are agent-specific security features, agent registration, and a consumption-based billing model. Agentic Identity would give AI agents their own identity rather than having them act under the identity of the human they assist, allowing separate credentials, finer permissions and better oversight.

Successful calls by registered agents, whether through MCP or direct APIs, will be counted as Headless Platform Interactions and drawn from Flex Credits, monitored through Digital Wallet. The author stresses that the Flex Credits multiplier has not been announced, agentic consumption is not yet metered, and Salesforce will give 30 days’ notice before metering begins. Traditional integrations keep their existing pricing and security arrangements.

Transition timing differs by customer type: new customers must register agents via APIs within three months of the Agentic Identity availability notice, existing API customers migrate at renewal, and MCP server users have three months from notice. Sandboxes, Scratch Orgs and Developer Edition orgs will not consume Flex Credits for HPIs. The author argues architects will need to plan for call volumes, permissions, monitoring and cost forecasting for multi-call agent tasks.

Read the original at dev.to (opens in a new tab)

Worth reading?

Recommended

Salesforce unveils an interface layer to connect platform data and permissions to AI tools (opens in a new tab)

Readers will understand how the new interface layer exposes Salesforce data, workflows, and existing permissions to external and internal AI applications without replacing the core CRM.

Why read this

The piece also clarifies the security model, the role of the Headless Toolkit, and how this capability differs from Agentforce.

Salesforce AIforce is a live interface layer that brings Salesforce data, workflows, business logic, permissions and governance into AI tools such as Claude, Slack and Lightning, so people can query records, update them and trigger workflows without opening the Salesforce app. Announced at Dreamforce, it is positioned as the top layer of Salesforce’s Agentic Enterprise architecture, above Agentforce, Customer 360 and Data 360. The Headless Toolkit, which exposes the platform through MCP servers, APIs, plug-ins and skills, connects these layers. Its three launch surfaces are Claudeforce (Salesforce in Claude, with 37 prebuilt sales skills, now in beta for all customers), Slackforce (Slackbot, Slack CRM and related tools) and Agentforce Coworker in Lightning.

The article explains that AIforce differs from Agentforce: Agentforce builds and runs the agents that do the work, while AIforce is the interface through which people and agents reach Salesforce from outside the app. Coworker bridges the two by calling agents a company has already deployed. On security, the article describes four points: requests run under the user’s existing permissions, hosted MCP servers are inactive until an admin enables them and are logged through Event Monitoring, approval can be required for changes or deletions, and Salesforce says business data is not retained by the model provider under Zero Data Retention. The author advises confirming those terms in the contract, and notes that pricing and availability can change and vary by region.

The piece also covers the naming question: Marc Benioff said on October 9 that AIforce is now SIforce, but Salesforce’s own product pages still used AIforce at the time of writing. It treats the name change as a signal to plan around permissions, data models and integrations rather than brand labels. A case study on BACA Systems, a 50-person manufacturer, describes an Inventory Agent in Slack, a Slack channel per field project, and an ACH payments module that removes card fees, with a projected saving of about $200,000 a year. The article stresses that these are Salesforce-published projections and that BACA’s ERP runs natively on Salesforce, which is unusual.

Finally, the article offers an illustrative scenario for firms whose ERP is SAP, Oracle or NetSuite, where a MuleSoft-style governed API layer is needed to answer cross-system questions. It closes with a six-step readiness checklist (data foundation, permissions, external systems, MCP policy, a single-team pilot, and monitoring) and the author’s view that AIforce amplifies whatever data and permission quality already exists, so organizations should start with packaged surfaces and proof for trust claims before building custom experiences.

Read the original at Cloud Odyssey (opens in a new tab)

Worth reading?

Recommended

New Flex Credit pricing for AI agents risks pushing customers toward ungoverned architectures (opens in a new tab)

Readers will learn how Salesforce plans to charge Flex Credits for AI agent interactions through MCP and direct APIs, and why this pricing structure creates financial pressure to bypass governed platform access.

Why read this

The article outlines practical steps for modeling usage volumes and optimizing agent workflows to control costs without compromising security.

Salesforce intends to bill Flex Credits when third-party AI agents successfully call into the platform via MCP or standard APIs. This pricing strategy conflicts with the company’s push for structured, governed machine access, creating a financial incentive for customers to minimize platform interactions.

Charging per successful interaction can lead to double billing alongside external AI vendor costs. Because autonomous agents generate significantly more API calls than human users, the cumulative expense grows quickly. Teams facing these costs may resort to duplicating data externally or routing logic outside Salesforce to avoid fees, which undermines the intended security and traceability benefits of Agentic Identity and the Headless Toolkit.

The author advises teams to accept the current policy while proactively modeling worst-case usage scenarios to forecast expenses. Practitioners should track exact interaction volumes, prepare data for negotiations with account executives, and optimize agent designs to reduce unnecessary calls. The guidance emphasizes maintaining governed architectures rather than building workarounds that violate platform policies.

Read the original at Salesforce Ben (opens in a new tab)

Worth reading?

Winter 27 release brings Headless Toolkit, Multi Framework support, and Data SDK extensions (opens in a new tab)

Readers will learn how to build cross-framework applications on the platform using the new Headless Toolkit and understand how to extend the Data SDK with custom logic.

The Winter ’27 release, whose final rollout is set for October 9, 2026, centers on the Headless Toolkit. Salesforce capabilities are exposed as APIs, Model Context Protocol (MCP) tools and CLI commands that any authenticated caller can use. The Salesforce Development plugin for Claude Code adds Salesforce-specific skills, org context and recommendations for specialized plugins, and its skills also work with other coding agents. Multi-Framework apps now support Angular alongside React, with new templates, 2GP packaging and a Data SDK that can package custom logic as typed extensions. Beta microfrontends let an app run inside a Lightning page, with data passed down from the host component and events sent back up.

The Headless Experience Layer (Beta) lets a developer define a widget once and render it in Agentforce, Claude and Slackbot, linked through Apex, Lightning type and widget metadata. MCP now works in both directions, so Agentforce agents can be exposed as tools on custom MCP servers and AgentExchange MCP tools can be added to agents. The Marketing Cloud Engagement MCP server gains 40 tools. The CLI stops printing access tokens and secrets, with the temporary workaround ending October 28, 2026, and it adds async Apex templates and Scratch Org settings. API version 68.0 requires the Use Any API Auth permission for SOAP login from December 1, 2026, retires API versions 31.0 through 40.0, and adds a latest alias for REST URIs.

In Lightning Web Components, template expressions and LWC:external reach general availability, and state managers gain a refresh() method. Apex heap limits rise to 10 MB for synchronous and 25 MB for asynchronous transactions, and integration tests, FORMULA() and the Apex Symbol API are in preview or beta. Agentforce gains new Agent Script language features, file uploads in conversations, and generally available Multi-Agent Orchestration, along with simplified agent metadata types. Data 360 adds a context precision metric for retrievers and Python code extensions for zero-copy data. Web Console, a browser-based IDE, is generally available and needs no installation.

Read the original at Salesforce Developers Blog (opens in a new tab)

Worth reading?