By Kamalnath Devarakonda · Salesforce EngineeringYou will also learn the integration, contract-testing and fail-closed patterns that made it trustworthy.
You will see how Salesforce's ROAM agent automates Change Advisory Board reviews by letting deterministic code decide while the LLM only explains.
Why read this
You will also learn the integration, contract-testing and fail-closed patterns that made it trustworthy.
Verify approver identity and role
Check linked passing QA test run
Confirm pull request and approval trail
Route to human if any gate is unverified
Write every outcome to audit table
ROAM's gate verifies each requirement independently, and routes unverifiable requests to a human
Salesforce Engineering describes ROAM, the Release Operations Agentic Manager, an Agentforce-pattern agent that reviews production patches for 18 Salesforce products. Before automation, requesters and reviewers chased approvals across Slack, change records, QA evidence and release calendars, with median turnaround around 24 hours. The team mapped the Change Advisory Board process first, then built ROAM on an internal platform providing event ingestion, durable workflow state and shared clients.
The main technical lesson concerns integration correctness. An early bug read the wrong field in nested Slack replies and silently dropped approvals, so the model received an incomplete picture. To guard against schema drift, the team added contract tests using recorded live payloads that run on every pull request, and a mismatch fails the build. The core design rule is that the gate decides and the LLM narrates: deterministic code verifies the approver’s identity and role, the linked test run, the pull request and the approval trail, and the model cannot produce or overturn the verdict. Output validation re-reads the change record and fails closed when an explanation contradicts the evidence.
When a gate cannot be verified, for example because of missing links, expired tokens or outdated rosters, ROAM routes the request to a human, which happens for about 8% of requests. Idempotency keys and decision hashes prevent duplicate posts and changing verdicts on retries, and every outcome is written to a durable audit table.
On AI-assisted development, the article notes that roughly 70% of ROAM’s codebase was drafted or refined with Agentforce-assisted coding, while engineers wrote the remaining 30%, and a separate verifier agent re-executes test suites rather than trusting a fix agent’s self-report. Over about 550 reviews in 10 weeks, the team reports zero incorrect approvals, a median response of about 12 seconds and a 95th percentile under 45 seconds, after which ROAM became mandatory for all production patches.
You will see how Agent Optimizer moves an Agentforce agent from first build through production monitoring, root-cause fixes and A/B testing.
Why read this
You will also learn which of these features are still in beta or coming soon.
Forming: Build the agent and pass custom-scored tests
Storming: Rank production problems across real sessions
Norming: Trace root cause and draft a fix
Performing: Prove the fix with A/B tests and keep it
Agent Optimizer moves an agent through four repeating stages, not a single launch
The post borrows Bruce Tuckman’s model of forming, storming, norming and performing to describe how an AI agent matures. Forming covers building the agent and proving it is ready before it meets customers. Agent Optimizer drafts the agent in Agent Script from a plain-language description, combining deterministic business rules with Atlas Reasoning Engine planning, and builds on existing Salesforce data, Flows, Apex and permissions. Testing with custom scorers is described as coming soon.
Storming is the period after launch, when real customers expose gaps. Agent Optimizer reads production sessions one by one and ranks recurring problems behind escalations, abandonment and low satisfaction. With session tracing enabled, it reads the reasoning trace for each response, showing the topic chosen, actions called, knowledge retrieved and citations. The post says Agent Optimizer is included at no extra cost for standard use cases.
Norming means finding and fixing the cause. Agent Optimizer traces each issue to the exact step where it failed, classifies it as a broken action, knowledge gap or off-topic request, and recommends a fix such as a clearer instruction, a new topic or a knowledge article. It can build and, once testing arrives, test the fix, with the team choosing how much it acts on its own.
Performing covers proving improvements. A/B experimentation, also coming soon, runs a change on a slice of live traffic against the current agent, judged by the same custom scorers, before a winning version ramps to all traffic. Each proven fix stays in the agent’s configuration, and the post says the cycle restarts whenever something changes. The post notes Agent Optimizer is in beta and points readers to their account executive and the help documentation.
You will learn how Carter is structured, with its four preconfigured subagents, page awareness and merchant controls over guided discovery, and what the Shopper Agent template gives you to start from.
Why read this
You will also see the customer results Salesforce reports, though they are vendor claims.
Shopper asks in natural language
Agentic Commerce Search reads the intent
Carter routes to a subagent
Answer grounded in the product catalog
How Carter handles a shopper request across its subagents
Salesforce introduces Carter, a shopper agent from Commerce Cloud that gives online shoppers a conversational interface in place of keyword search and category pages. The article argues that shoppers now expect the guided, context-aware help a good in-store sales associate gives, and that Carter is meant to provide it. It is available through B2C Commerce and can be reached from the search bar, the header icon, or FAQ widgets on product detail pages.
Carter is powered by Agentic Commerce Search, which interprets the intent behind a natural language request rather than matching keywords. Its answers are grounded in the merchant’s product catalog, and brands can add other knowledge sources through Data 360. Merchants control how Carter sells by choosing which follow-up questions are required or optional in guided discovery and which selling points it highlights when comparing products.
Getting started means using the Shopper Agent for B2C Commerce template in Agentforce, which comes with all the subagents and actions preconfigured. Product Expert handles browsing, search, recommendations, comparisons and product questions. Site FAQ covers policies such as shipping, returns and refunds. Cart manages products, variants, promotions and coupons. Order Confirmation confirms orders and recovers carts after failed or cancelled payments. Carter orchestrates these behind one chat, and because it is page-aware it can answer questions about the product or cart the shopper is currently viewing.
The article cites several retailers using Carter under their own brand names, including Cuisinart’s Compass, Hibbett AI and SharkNinja’s combined commerce and support interface. Hibbett reports going live in six weeks and handling 90% of core shopper journeys. These are vendor-supplied results. Carter is generally available now as an add-on for B2C Commerce customers and works in every language Agentforce supports.
You will learn eight writing principles for prompting an agent on admin work, and see a weak prompt rewritten into a strong one for a Validation Rule.
Why read this
The advice applies to any agent request you make.
Joshua Birk argues that prompting an agent is a writing skill rather than a form of engineering, and that admins can apply the communication habits they already have. He notes that a good prompt is usually three to six plain-language sentences that name the exact objects, fields and Flows by API name, explain the business reason, and state the output wanted and the guardrails. A one-line prompt tends to cost several rounds of clarification, while a few extra sentences up front save them.
The article then sets out eight lessons: know your audience, lead with the goal, be specific, give context and explain why, define the output format, show examples, use plain language, and set constraints. Each comes with an admin example, such as naming the team size so the agent pitches its answer correctly, or pasting an existing Validation Rule so the agent follows its naming pattern. Constraints such as working only in a sandbox or not touching active Flows are written into the prompt from the start.
To show the lessons together, Birk rewrites a vague request to create a close-reason Validation Rule into a detailed prompt covering the object, field, error message, naming convention, length limit and a no-deploy instruction. He closes by saying that one prompt rarely produces a finished solution, so admins should plan follow-up prompts, and he points to Trailhead modules and a GitHub kit of 100 admin prompts.
You will learn why the same business metric can differ across Salesforce and an ERP, and how a versioned metric contract naming one source of truth and owner per number prepares data for an AI agent.
Won opportunities
Sums Amount on Opportunity
Filters on IsWon and CloseDate
Measures closed deals this month
Activated orders
Sums TotalAmount on Order
Filters on Status and EffectiveDate
Measures orders effective this month
Two valid queries for the same business question can return different totals
A sales manager asking for one figure often gets three answers: the CRM, the ERP and a spreadsheet each record a different moment of the same sale. The author says this is common in mid-sized companies running Salesforce beside a separate ERP, and that an AI agent given access without resolving it will simply pick one number.
The piece illustrates the problem with two valid SOQL queries for sales this month: one summing won Opportunities by close date, the other summing activated Orders by effective date. Both are correct and can return different totals on the same day, while invoicing in the ERP follows its own date logic.
The proposed fix is a metric contract, a short versioned YAML file. For each metric it names the question, the definition, the source of truth, the object and filter, the amount field, an owner, what the metric is not, and any metrics it reconciles with along with the expected gap. The example pairs a sales_this_month metric on the Order object with an invoiced_this_month metric held in the ERP.
The author’s practical rules are to give the agent the contract as context rather than only database access, to flag metrics that depend on spreadsheets as candidates for removal, and to review the contract when processes change, as one would review code. The article also notes that a single data source avoids much reconciliation work, and it promotes the author’s own ERP product built natively on Salesforce.
You will learn what Koa is, the role a reasoning model plays inside an Agentforce agent, and how Salesforce's own benchmark results compare it with GPT-4.1 and GPT-5.5.
Why read this
You will also see why those results need independent confirmation before you rely on them.
87%: Koa multi-step CRM tasks completed
82%: GPT-4.1 multi-step CRM tasks completed
91%: GPT-5.5 multi-step CRM tasks completed
Koa's results on Salesforce's own internal CRM benchmark, reported in the paper
Salesforce announced Koa at Dreamforce 2026 as its first AI reasoning model built specifically for CRM work. Inside an agent, the reasoning model decides which steps to take, in what order, and which tools to use, while the rest of the agent carries them out. Koa runs behind the scenes, and admins choose it for an agent the same way they choose any other model.
Salesforce argues that general-purpose models reason from scratch on every task and may not behave the same way twice, whereas CRM work is largely repetitive and rule-based. It claims a model trained on that work will be steadier, and that it should be better at recognising its own limits and saying when it cannot do a job. The article notes that Salesforce claims three times fewer errors on CRM tasks, but does not say which models it was compared against, and the paper does not contain that figure.
The paper’s own numbers are more mixed. On multi-step CRM tasks Koa completed 87%, against 82% for GPT-4.1 and 91% for GPT-5.5. On a single-step CRM score it reached 0.87, against 0.81 and 0.90. Koa beats GPT-4.1 but trails GPT-5.5 slightly, and all results come from Salesforce testing its own model, with no independent evaluation yet.
Salesforce says Koa was trained on simulated and public data only, and it does not replace other models, which stay available for each agent. Koa is still in pilot, so most orgs cannot switch to it yet. The article suggests building a small test set of real agent tasks with known-good outcomes now, so Koa can be compared fairly when it arrives, and it stresses that clean data matters more than the model.
You will learn how to turn the OpportunityHistory object into an event log and use pandas to find stage variants, skipped stages, waiting times and single-person bottlenecks.
Why read this
You will also see what these findings should settle before an AI agent is given the sales process.
Export OpportunityHistory as an event log
Build stage variants and count rework
Measure median wait between stages
Count who moves the stages
The four analyses used to measure the real sales process from OpportunityHistory
The author argues that a documented sales process often differs from the one a company actually runs, and that an AI agent will faithfully follow whichever version it is given. Before automating, teams should measure the real process. Salesforce already records a row in OpportunityHistory whenever an opportunity’s stage, amount or close date changes, so no setup is needed. A SOQL query selecting the opportunity ID, stage, amount, close date, creation date and creator over the last 180 days can be exported to CSV and used as an event log.
The post then walks through four analyses in pandas. The first removes rows that are not real stage changes and counts the distinct stage paths, or variants, across opportunities; the documented process is usually one line, while the data usually shows many. The second flags opportunities that went back to an earlier stage and those that moved from creation to the last stage in two steps or fewer, which suggests the CRM was updated only at the end. The third calculates the median wait between each pair of stages to locate handoffs or approvals that happen outside the system. The fourth counts how many stage changes each user made, since one or two users moving most records suggests updates are being collected elsewhere and typed in.
The author stresses that these numbers show where the problems are, not why they occur. Each signal should prompt a question: which process is the real one, what the rep gains from updating the CRM, which area owns a slow handoff, and where the information actually lives. Answering these first prevents an agent from speeding up the wrong steps. The same approach can extend to orders, invoices and payments when the ERP lives in the same Salesforce org.
You will learn the two routes a Headless Experience Layer widget takes from a user's question to a card on screen, one through Agentforce and one through MCP clients, and where each route fails.
Why read this
You will also see how to troubleshoot a missing card in each.
Route 1: Agentforce
LLM calls show_tool_results
LLM sees result plus ID only
Agentforce Client draws with Lightning Web Components
Route 2: MCP clients
Host shows any tool with a renderer
LLM sees data, never the widget
Renderer draws in a sandboxed iframe
The two routes differ in who decides to show the card and who draws it
The Headless Experience Layer beta lets a developer define a widget once and show it as an interactive card in Agentforce, Slackbot, Claude and ChatGPT. How the widget appears depends on the client the user is chatting in, and the article splits this into two runtime routes. The example throughout is a customerReviews widget from the Pronto sample app, which an agent produces by calling the getCustomerReviews Apex action.
In Route 1, inside Agentforce, the runtime stores the action’s output under a short ID and marks it as displayable when the surface supports widgets and the action is flagged is_displayable. The LLM then calls the built-in show_tool_results action with that ID, which carries only a caption and the ID. The runtime resolves the result and its Custom Lightning Type, and the Agentforce Conversation Client hydrates the widget in the browser from JSON. Rendering depends on the model choosing to make that call, so the article suggests asking for the card in the agent’s instructions.
In Route 2, an MCP server advertises a renderer address for each tool. The client loads the HXL renderer in a sandboxed iframe and calls the tool, and the server returns text for the model, the raw structured output, and a hydrated widget in metadata. The host pushes the widget into the iframe, while the LLM reads only the data and writes the answer.
The article closes with a comparison of the two routes on who decides to show the card, what the LLM sees, where data meets the widget and who draws it. It also gives a troubleshooting checklist for each route, including checking for the is_displayable flag, the show_tool_results call, the resource URI in tools/list, and whether the tool call returned an error.
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.
The reader will learn what Agentforce Coworker does, how to find out whether it is already enabled in their org, and why sharing and permissions should be reviewed before rollout.
Check whether Coworker is already on
Review sharing and fix over-broad access
Build a few focused agents
Tell users what Coworker can do
A suggested order for rolling out Agentforce Coworker in an org
Agentforce Coworker is described as Salesforce’s AI assistant for employees, sitting in the search bar and routing user requests to specialist agents. Without well-built agents it can still answer questions from org data but can do little else. The article says it reached general availability at Dreamforce and that more than 185,000 people use it.
The article notes that from August 10, 2026, Salesforce automatically turned on Coworker for customers with unmetered user-based AI seats, which can be checked under Setup, Agentforce Coworker. HIPAA, health and life sciences, and government orgs were not auto-enabled, and Coworker is not covered by the HIPAA Business Associate Addendum. Pricing is said to depend on contract terms.
The main warning is that Coworker respects each user’s existing permissions and Sharing Rules, so it will surface any over-broad access quickly. The suggested rollout is to check the enablement setting, review sharing first, build a few focused agents for common requests such as renewal risk and case status, and tell users what the assistant can and cannot do.
You will learn how the new AiAgentDefinition and AiAgentDefinitionVersion types replace Bot, GenAiPlannerBundle and AiAuthoringBundle for Agentforce agents, how to write a manifest and retrieve a single version with its dependencies, and which deployment rules and migration steps apply.
Agentforce agent at API 68.0
AiAgentDefinition
AiAgentDefinitionVersion
AiAuthoringBundle
The three old metadata types and the two new types that replace them
Winter ’27 introduces two metadata types for Agentforce agents at API version 68.0: AiAgentDefinition, which holds agent-level settings, and AiAgentDefinitionVersion, which holds one version’s settings, messages and an inline planner with its subagents and actions. Under the previous structure, one agent was spread across the Bot, GenAiPlannerBundle and AiAuthoringBundle types, with generated name suffixes, hard-to-find welcome messages and folder names that changed between retrieves. The author compares a sample agent retrieved at API 67.0 and 68.0, showing that the content was identical and only the names and packaging changed.
At API 68.0, Agentforce agents must use the new types, and retrieving or deploying them as Bot or BotVersion returns an error. The # delimiter lets a manifest or the –metadata flag select a single version, such as TestAgent#1, all versions with TestAgent#, or every version of every agent. Salesforce CLI version 2.149.9 or later is needed, and the –root-type-with-dependencies AiAgentDefinitionVersion flag pulls in the parent definition, the authoring bundle and the Flows, Apex classes and Prompt Templates the version uses. The dependency retrieve is limited to 25 requests per day, 100 components per request, and one level deep.
Deployments fail if the old and new formats are mixed, if a version is deployed without its definition existing in the target org or the same deployment, or if the Agent Script source is omitted. The author also notes that the agent user from the source org must be replaced for a draft agent, and recommends switching to API 68.0 in its own commit and updating any scripts that parse the old files.
You will learn what Salesforce Catalog indexes, how it grounds AI answers and code generation in your org's real object and field names, and how an admin enables it and connects an AI assistant or the Data 360 MCP server.
Without Catalog
Agent guesses field names
Deploy fails on unused field
Engineer or Setup review needed
With Catalog
Agent searches the live index
Returns closest real matches
Answers only what user may see
Catalog lets an agent check the org's real names before it answers or writes code
Salesforce Catalog is an index of how an org is built, covering Objects, Fields, Flows, Apex, Permission Sets, users, and Data 360 components such as data streams, calculated insights and segments. It updates as teams deploy changes, so no separate documentation has to be written or maintained. An AI assistant or agent consults the Catalog before answering, and every question runs as the signed-in user, so answers are limited to what that user may see.
The article gives examples from a service operations manager tracing a CSAT figure back to its source, a data owner checking what depends on a field before changing it, and a developer who avoids using an unused field name. Catalog matches questions by meaning as well as by name, returns a short ranked list of candidates, and lets the agent read details only for those, which the article says keeps responses fast in large orgs and reduces failed deploys.
An admin enables Catalog in Data Cloud Setup and turns on the MCP Server, then connects an AI assistant such as Claude, ChatGPT or Cursor, or Agentforce Vibes, which comes preconfigured. Teams building their own agents can use the Data 360 MCP Server, and Agent Context Engine uses Catalog to supply context. The article notes that Catalog is available in every edition that supports Data 360 and points to a setup guide for steps and permissions.
You will learn what Koa Decisions is, how it differs from a general-purpose LLM for categorical decisions, and the latency figures Salesforce reports.
Why read this
You will also see the planned extension to flows, Apex and Prompt Templates.
General-purpose LLM
Generates text token by token
Roughly 1.4 seconds for routing
Built for writing and reasoning
Koa Decisions
Reads the whole request at once
Roughly 26 milliseconds for routing
Returns a choice, yes/no or score
A decision model returns a short answer far faster than a general-purpose LLM
Salesforce is releasing a new version of Koa Decisions, an AI decision model built on its HyperClassifier model and trained on Google’s open-weight Gemma. It takes a request and a list of categories you define, and returns a choice, a yes or no, or a score within milliseconds. The latest version adds multimodal support for images and audio.
The article argues that a general-purpose LLM is slower and more costly for quick, targeted decisions such as routing a request to a team. A decision model reads the whole request at once and can return an answer in as little as one token, while an LLM generates text token by token. Salesforce reports that, when routing requests in Agentforce, the decision model took roughly 26 milliseconds against roughly 1.4 seconds for a general-purpose LLM.
Salesforce plans to extend the model beyond routing into flows, Apex and Prompt Templates, with an API for developers. The company frames it as a way to keep larger models for reasoning and generation while smaller models handle routine decisions.
You will learn the five checks to run when an Agentforce Service Agent fails with a field-access error while answering from Knowledge articles, and the order to run them in.
Why read this
The piece is a practical troubleshooting guide rather than new platform news.
Assign Data Cloud User Permission Set
Grant Read on Knowledge and mapped fields
Enable Allow View Knowledge
Verify data space access
Confirm search index is Ready
The five checks to run in order when the field-access error appears
The article covers an error that appears when the Answer Questions with Knowledge action runs against an Agentforce data library: the agent’s running user cannot read one or more fields the library depends on. The usual causes are missing permissions, missing field-level security, or an incomplete Data Cloud setup. The agent runs as the user with the Einstein Agent User profile, and every object, field and Data Cloud resource the data library touches must be readable by that user.
The guide gives five checks in order: confirm the Data Cloud User Permission Set is assigned to the agent user, confirm Read access on the Knowledge object and every mapped field, enable Allow View Knowledge, verify the user’s data space access in Agent Studio, and confirm the search index for the Knowledge data library is Ready. It also recommends a dedicated Permission Set for the agent user, re-auditing field-level security whenever the library changes, granting least privilege, and testing as the agent user rather than as an admin.
The author notes that the source material contained no code, and that the link between an unready search index and this specific message is not confirmed in the source, so it should be checked as a separate cause.
You will learn what Builder Central does beyond Setup with Agentforce, how its metadata visualizations and preview orgs protect your org, and the steps to enable the beta.
Describe the app or agent in plain language
Answer clarifying questions
Review metadata and test in preview org
Deploy to sandbox via Lifecycle Center
Builder Central takes a solution from plain-language idea to sandbox deployment
Builder Central is a new no-code experience in beta that lets admins build and deploy apps and agents from plain-language prompts. It works as one hub for work that would otherwise be spread across Setup and several builders, and it draws on the org’s existing data model, configuration, security and permissions so that what it creates fits the business and inherits access controls.
The article distinguishes it from Setup with Agentforce, which makes direct, simple administration changes such as creating a field. Builder Central targets larger builds like full data models, flows and agents. It asks clarifying questions before building, deploys through Lifecycle Center, and complements Flow Builder, Lightning App Builder and Agentforce Builder rather than replacing them.
To keep orgs safe, it offers interactive metadata visualizations for reviewing generated components and ephemeral preview orgs, temporary clones of a sandbox, where solutions can be tested before anything is published. To start, admins grant the Access Builder Central user permission, enable the beta feature and activate the Metadata Experts MCP Server in Setup, ideally in a Developer or Developer Pro sandbox.
You will learn what Agentforce Coworker now does across Microsoft Teams, mobile and desktop, what is available now versus later, and how it respects Salesforce permissions and governance.
Employee delegates a job
Coworker plans the steps
Agents and flows run
Results return for review
How Coworker handles a delegated job, as described in the article
Salesforce reports that more than 185,000 users are working with Agentforce Coworker, with usage up 21x in three months. The release adds Conversation History, reusable Skills and scheduled tasks, plus connections to Google Workspace and Microsoft 365 so that email, calendar and file data can sit alongside Salesforce records. Coworker can be used from Microsoft Teams and new iOS, Mac and Windows apps.
Coworker plans multi-step jobs, coordinates Agentforce agents, flows and business actions, and returns results for review. It is described as working within existing Sharing Rules, permissions and configured access controls, with approval and audit capabilities for supported operations. A new $50 per-user, per-month option is offered for predictable budgeting.
Availability is staged: Google Workspace and Microsoft 365 connectivity, Conversation History, Skills and the per-user SKU are available now; the Teams, iOS and desktop apps and a Coworker MCP server are slated for November 2026; Daily Digest, scheduled tasks and mobile apps for Field Service, Consumer Goods Cloud and Life Sciences Cloud are expected in December 2026. The article notes pricing and features may change, and much of the piece is customer testimony and marketing framing.
You will learn what a decision model is, how it differs from a general-purpose LLM for choosing among options, and how Koa Decisions is positioned to reach flows, Apex and Prompt Templates.
Why read this
The article also points to a free Trailhead demo for testing it.
Decision model
Reads the whole request at once
Returns one choice in one step
About 26 ms in Agentforce routing
General-purpose LLM
Writes its answer token by token
Generates text before the choice
About 1.4 s in Agentforce routing
A decision model returns one choice directly, while an LLM writes its answer token by token
Salesforce has introduced Koa Decisions, the next version of its HyperClassifier model. It reads a request and a list of categories the user defines, then returns a decision in a single step, in milliseconds. It was built by applying training techniques to Google’s open-weight Gemma model, and it adds multimodal support for images and audio. Salesforce plans to extend it beyond Agentforce routing into flows, Apex and Prompt Templates, plus an API for developers. It joins a separate reasoning model built with NVIDIA in the Koa family.
The article argues that much of an agent’s work is choosing an option, a yes or no, or a score rather than generating text. A decision model returns that choice directly, while an LLM writes its answer one token at a time. In Agentforce routing measurements, the decision model took roughly 26 milliseconds against about 1.4 seconds for a general-purpose LLM. New categories can be added without retraining, which the article contrasts with building a custom predictive model over months.
Readers can test the model through the Koa Decisions demo on a free Trailhead account by changing the options and request text. The article also notes pricing and availability are subject to change and vary by region.
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.
Describe the page in natural language
Review a live preview as it is built
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.
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.
You will learn how Salesforce assesses knowledge content before indexing, how it tests Data 360 retrieval changes against a golden data set, and why a human-reviewed failure rate matters more than raw metrics.
Hypothesize how the change affects answers
Build the recipe in Data 360
Evaluate with quantitative and qualitative tests
Reject or deploy, then keep monitoring
The loop used to test each change to the agent's Data 360 configuration
The Salesforce Help Agent is grounded in Salesforce’s own product knowledge, prepared and organized in Data 360 and used by Agentforce through retrieval augmented generation. The authors argue that an agent’s answers can be no better than the content it retrieves, so content quality has to be checked before any model or configuration work starts.
The first lesson is a Fit, Gap, Clash review of every article: whether it answers a real question, whether it leaves a customer issue uncovered, and whether it contradicts other content. Articles are scored using health, failure, resolution and traffic signals, paired with top case drivers. More content does not mean better coverage, and the team chose a separate agent for the Informatica help portal rather than adding that content to the existing Help Agent, which now resolves 92% of questions on that site without a case being filed. Content authors and an AI and Data team share the work, with Agent Managers connecting them.
The second and third lessons describe building by hypothesis: each change to a Data 360 recipe is tested, and only changes that improve answers ship. A product-name metadata hypothesis showed flat results and was rejected, leading to a new recipe that pairs metadata with prompt instructions. Evaluation uses a golden data set of about 200 utterances, each validated by a person, with acceptance criteria covering correct, complete and relevant answers.
The final lesson combines deterministic retrieval metrics, semantic quality checks and business outcomes with human and LLM review. When section-aware chunking was tested against fixed-size chunking on 195 query-document pairs, metrics flagged 8 failures, but review showed the real failure rate was closer to 1%, and that figure was used to approve production.
By Itai Asseo and Egor Pakhomov · Salesforce BlogYou will also see how a policy that treats updates as corrections differs from one that files them as new facts.
You will learn how Salesforce AI Research measured agent memory end to end and that a revised memory policy, not an architecture change, roughly doubled recall in Agentforce.
Why read this
You will also see how a policy that treats updates as corrections differs from one that files them as new facts.
Previous policy
Keeps less of what customers say
Files an update as an extra fact
Updated policy
Keeps more of what customers say
Treats an update as a correction
The updated memory policy compared with the one it replaced
Salesforce AI Research built an evaluation framework that generates long, multi-session conversations with specific facts planted along the way, runs them through the live Agentforce system, and then asks questions that depend on those facts. Testing the full path, from the moment a customer mentions something to the moment an agent acts on it, is presented as what makes the result trustworthy. The conversations come from ConvoMem, a public benchmark released in 2025.
The framework was used to improve Agentforce Memory, which became generally available in September. The updated memory policy holds on to more of what a customer says and treats an update as a correction to something the agent already knows, rather than as an additional fact stored alongside the first. According to the article, the policy recalls 1.8 times as many explicitly stated facts and 2.2 times as many facts that change over time compared with the policy it replaced. The underlying architecture is unchanged.
The authors argue that measuring in production matters because memory only behaves like memory under real conditions, and they cite a travel platform customer whose employee-facing agent now carries context across conversations. The article is largely promotional and gives few methodological details beyond the headline ratios.
You will learn what the August 2026 refresh of the Platform App Builder exam changed, including the heavier Flow focus and the new Agentforce coverage, and how to adjust your study plan accordingly.
63%: Previous pass rate
73%: Pass rate after the refresh
32%: Share of exam for Business Logic and Process Automation
The exam refresh moved the pass rate up by ten percentage points
The Certified Platform App Builder exam was refreshed on August 21, aligned to the Summer ’26 release, and its pass rate moved from 63% to 73%. According to a podcast interview with Salesforce’s Alexis Kingma, the largest change is depth on Flow. Candidates are now asked to choose the right flow type for a scenario, troubleshoot a broken flow, and maintain and monitor flows over time, rather than simply show they can build one.
Agentforce is also included, but framed as one automation tool within the app builder’s toolkit rather than as a specialist topic. Candidates should recognize when it is an option and when reaching for it makes sense. Salesforce said the passing score was set using the Angoff method, in which a panel of experts estimates how many minimally qualified candidates would answer each question correctly. A higher passing score therefore means the panel expected a borderline candidate to get more questions right, which the author reads as a higher bar for the role.
The author advises budgeting time for Flow troubleshooting and monitoring, studying Agentforce under the Business Logic and Process Automation section (32% of the exam), using the Trailhead trail as a guide to likely topics, and reading the verbs in the exam guide objectives closely, since “create and configure” implies hands-on skill while “describe” implies conceptual knowledge.
You will learn what Salesforce Headless 360 offers through its three access paths, why governance has to move from the UI to the schema, and how to start a controlled pilot with a Hosted MCP Server.
Pick one workflow
Audit the schema
Connect a sandbox client
Define agent identity and limits
Test, trace and measure
A five-step plan for a first Headless 360 pilot
Salesforce Headless 360 is an architecture that exposes Salesforce capabilities through APIs, Model Context Protocol (MCP) tools and CLI commands, so AI agents, apps and developer tools can use the platform without a browser. Announced at TDX 2026, it keeps the data, workflows and business logic built over 25 years, and the company now also calls the offering Headless Toolkit. Salesforce cites more than 60 MCP tools, 30 preconfigured coding skills, 4,000 APIs and 220 CLI commands, and states that Lightning and the browser remain available for human users.
The piece explains three access paths. APIs serve developers and integration platforms that read and write records. MCP tools let AI clients such as Claude, ChatGPT and Cursor discover and call capabilities at runtime, with no custom integration code written in advance. CLI commands support scaffolding, testing and deployment through DevOps pipelines. MCP tools are further split between coding agents, which read metadata, generate Apex and deploy, and business agents, which reach Salesforce from Slack or other chat clients. Hosted MCP Servers became generally available in April 2026, and the Headless 360 MCP Server followed in beta in July 2026. Every Hosted MCP call runs as the authenticated user through an External Client App with the mcp_api scope, and the article warns that pricing via Flex Credits may bill for usage, so teams should confirm terms with their account team.
For architects, the central change is that governance moves from the screen to the schema. An agent never sees a page layout, so Validation Rules, sharing models, Apex and approvals must carry the controls. The article proposes a four-layer view of experience, access, execution and data, and lists review questions about rule placement, least-privilege Permission Sets, human-only actions and approval points for high-risk actions. It also covers the Headless Experience Layer and Multi-Framework support for React, and notes that agent testing needs evaluation sets, session tracing and the Agentforce Testing Center. MuleSoft supplies governed access to systems outside Salesforce, while Data 360 supplies unified customer context.
The article suggests starting with one workflow, auditing the schema, connecting a sandbox Hosted MCP Server to one client, defining agent identity and limits, and then testing, tracing and measuring results against the manual process. It treats vendor customer stories as reference points only and advises a pilot to generate real evidence.
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.
Ground in business context via Data 360
Interpret requests and act through tools
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.
You will learn the workflow for defining business metrics in OSI YAML, converting them to a Tableau SDM, validating and querying the model, and exposing it to Agentforce and MCP clients.
Why read this
The piece gives the concrete API commands needed to do this.
Ingest CRM data into DLOs
Define metrics in OSI YAML
Convert to SDM JSON
Create and validate the model
Query via Semantic Query API
The workflow runs from ingested data through the OSI specification to a queryable semantic model
The post argues that AI agents need a shared semantic layer so that terms such as revenue and pipeline are defined once and reused across reports, applications and agent answers. Data 360 ingests CRM records into data lake objects, and a Tableau semantic data model adds relationships, metrics and calculations on top of them. Business context is captured first in an OSI YAML specification, which the Salesforce converter translates into an initial SDM JSON file.
The article walks through creating, validating and querying the model with Salesforce APIs, including the converter command, the model creation and validation requests, and a semantic gateway query. It also covers business preferences that steer agent terminology and scope, and verified questions created through Q&A Calibration to make answers more consistent. Agentforce and Claude connected through MCP are shown answering the same pipeline question from the same model.
The post notes that governance through Data 360 classifications, tags and policies can limit access to sensitive data. Its conclusion recommends starting from one business question, defining its terms, validating results, and then extending the shared foundation to more questions and agents.
You will see where the Salesforce ecosystem is growing and shrinking, from partner counts and talent demand to salary trends.
Why read this
The piece shows why demand is shifting toward AI, data and revenue skills and away from generalist platform roles.
+14%: Consulting partners, to a record 4,247
−13%: Global demand for Salesforce talent, year on year
$3.9B: Agentforce and Data 360 annual recurring revenue
Partner growth and talent demand moved in opposite directions in 2026
Salesforce itself continues to grow. Its Q2 FY27 revenue reached $11.3B, up 11% year on year, with a $456M Informatica contribution, and Agentforce and Data 360 annual recurring revenue approached $3.9B. Even so, IDC shows Salesforce’s CRM market share slipping to 20% in 2025 from 20.7% in 2024.
The 10K Salesforce Ecosystem Report for 2026 counts a record 4,247 consulting partners, up 14%. Growth sits almost entirely among small firms with five or fewer certified experts, while every consulting tier above ten experts shrank. Global demand for Salesforce talent fell 13% year on year, though the authors say demand for AI, data and revenue management skills grew sharply while generalist skills dropped.
The author’s Salary Survey 2026 points the same way: 89.4% of respondents found the market harder than in past years, and among those who changed jobs, 41.6% reported lower pay against 22.6% who reported higher. The conclusion is that the ecosystem is changing shape, with growth concentrated in specialist areas and pressure on generalist roles, large firms and individual bargaining power.
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.
Agentforce agents and actions in the org
Hosted MCP Servers expose the tools
External Client App connects the client
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.
You will learn how Builder Central plans and builds a Custom Object, List View and Permission Set from a plain-language prompt, what it leaves for the Admin to finish, and how it fits beside Lightning App Builder and Flow Builder.
Describe the app in a prompt
Review the project plan
Build in a separate workspace
Publish to the org
Assign the Permission Set
The order in which Builder Central moved the Bulk Delivery Management app from prompt to live use
The author tested Builder Central, a beta conversational workspace for planning, building, previewing and deploying Salesforce apps and agents from plain language. He described a spreadsheet replacement app in one prompt, naming a Custom Object and its fields, and Builder Central first produced a project plan for review before building anything in its own separate workspace.
After the initial build it suggested extra customization, such as a List View, which he accepted. He published the app, asked Builder Central to assign the Permission Set to his user, and then opened the app from the App Launcher. The build took about 12 minutes in real time, though he sped up parts of the video.
The result was not complete: the record page did not show all fields, so he adjusted it in Lightning App Builder. He argues the change matters less for saving time than for shortening the loop between requirements meetings and a working prototype, while Admins still own permissions, automation, user experience and testing. He recommends trying it in a sandbox, recreating an existing app conversationally, and checking the beta limitations.
You will learn how to express conditional display, badge coloring, arithmetic and blank checks as formulas inside HXL widget JSON, what the formula functions can and cannot do, and why deployed widget schemas can only grow.
Before: Apex
Precomputes ratingVariant
Computes winRate in Apex
Sends hasPhone and hasOpenPipeline
After: widget formulas
CASE() picks the badge variant
IF() guards the win rate division
NOT(ISBLANK()) checks the phone
Display logic moves from the Apex DTO into the widget itself
HXL widgets are declarative JSON components, currently in beta, that can be embedded in Claude, ChatGPT and Agentforce. Their {!…} expressions can use math, comparison and logic operators and functions such as IF, CASE, AND and LEN, so display logic can sit beside the display rather than in Apex. The author shows an account card whose display fields were first precomputed in an Apex DTO and then replaced with formulas for visibility, badge variant, win rate and phone presence.
The author notes limits. There are no formatting functions for dates or currency, so those values still need formatting in Apex, and there is no aggregate such as SUM or AVERAGE across a list. Moving an existing widget also has a catch: a deployed schema.json can only grow, so removing old properties requires deploying a new widget bundle and repointing the Custom Lightning Type renderer.
The post also points to the Headless Experience Layer Playground for testing formulas live and to a formula reference in the Salesforce platform-widget-generate skill for coding agents.
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.
Readers will learn the updated Spring 2026 Agentforce Specialist exam structure, key topic weights, and a hands-on preparation plan using Developer Edition orgs and core platform tools.
The Spring 2026 Agentforce Specialist exam has been restructured, removing separate Sales Cloud and Service Cloud sections while adding Agent Script, hybrid reasoning, Testing Center workflows, governance, and multi agent orchestration. The assessment consists of 60 scored multiple choice questions plus five unscored ones, lasts 105 minutes, requires a 72 percent passing score, and costs 200 dollars to register.
A four week preparation strategy emphasizes practical application over rote memorization. Week one focuses on prompt engineering and the Trust Layer using field generation and flex templates grounded in record data. Week two covers Data Cloud fundamentals, guiding readers to build a file based Data Library and connect policy documents to test retrieval behavior. Week three shifts to agent creation, requiring the construction of an agent with Flow backed actions and deterministic decision filters. The final week covers the Testing Center, deployment procedures, analytics, and governance monitoring.
Common study mistakes include relying on outdated outlines, underweighting the AI Agents section, treating Data Cloud as optional, and ignoring annual maintenance requirements that expire the certification. The article concludes that demonstrating configured solutions and tested agents during technical interviews carries more weight than the certification badge alone.
Readers will learn how to configure a custom retriever in Agentforce Studio, create a Flex Prompt Template in Prompt Builder, and deploy a subagent that grounds responses in live Data Cloud vector data.
The article explains how to configure a custom retriever in Agentforce Studio to fetch vectorized chunks from a Data Cloud data model object. It details setting result limits, mapping target fields, and activating the retriever so it can be referenced elsewhere.
Next, it walks through creating a Flex Prompt Template in Prompt Builder by modifying a standard knowledge template. The author shows how to add the retriever as an action, bind the query parameter, and write strict instructions that force verbatim source extraction and handle missing data gracefully.
Finally, the piece covers assembling an Agentforce Service Agent, keeping only essential routing subagents, and linking the custom Prompt Template as an action. The author validates the workflow by testing destination queries and confirming the agent returns accurate, grounded answers sourced directly from the live Data Cloud index.
Readers will learn a structured six-point checklist for evaluating the security, permissions and costs of agents and MCP tools before they reach production.
Why read this
The guide explains how to test these integrations safely and establish ongoing monitoring.
The article outlines the transition of AppExchange to AgentExchange, noting that the marketplace now hosts agents, subagents and MCP servers alongside traditional managed packages. It emphasizes that these newer components operate at runtime rather than just adding static metadata, which changes how administrators must assess their impact.
Authors provide a six-step verification process covering security review status, profile access limits, data flow mapping, agent user permissions, pricing structures using Flex Credits, and publisher reputation. They stress that passed security reviews set a baseline but do not guarantee safe runtime behavior.
The piece recommends a Sandbox evaluation workflow that includes testing under different user states, allowing only necessary MCP tools, enabling logging, and modeling costs at projected volumes. It concludes with operational rules such as enforcing least privilege, requiring weekly transcript reviews during pilots, and defining offboarding procedures before deployment.
Readers will understand how external inputs can bypass controls to reach Agentforce internal instructions, and why current governance models struggle to monitor these paths.
Researchers have identified a security vulnerability in Salesforce Agentforce where automated flows create unauthenticated pathways from external customer messages directly into internal program instructions. This occurs when services convert emails or web submissions into support records and pass them through chained integrations.
The primary challenge highlighted is a lack of visibility into these execution environments. External monitoring tools cannot easily inspect what happens inside the program boundaries, making it difficult to track risk profiles or detect unauthorized access attempts.
The article notes that similar exploitation tactics are part of the City-Forum data theft operation targeting enterprise platforms since March 2025. It also emphasizes that relying on written security policies without operational proof exposes organizations to significant regulatory fines under European Union artificial intelligence regulations.
Readers will learn how to securely link ChatGPT and Codex to Salesforce data and development environments using official plugins and the DX MCP connector.
Why read this
The piece also outlines model selection strategies and permission handling to keep workflows reliable.
OpenAI Salesforce Integrations
External data plugins
Agentforce Sales app plugin
Tableau plugin
Salesforce DX MCP connector
Key plugins and connectors linking OpenAI tools to Salesforce workflows
The article is a guide to OpenAI’s product line and how Salesforce professionals can connect it to their work. It explains that ChatGPT is now delivered mainly through a desktop app that combines chat with Codex, and introduces ChatGPT Work, an agentic mode that carries out multi-step tasks across Connected Apps and files. It also covers Codex, OpenAI’s coding agent available through the CLI, IDE, desktop and web; Dots, always-on autonomous agents that can run tasks after a chat ends and can even coordinate Codex work; ChatGPT inside Slack and Microsoft Teams; and the Spaces, Pages and Sites tools for shared projects, interactive documents and live web apps built from Codex.
On features, the piece describes plugins as the means of giving the AI access to external data, with the Salesforce plugin (formerly the Agentforce Sales app) letting users read and edit CRM records from ChatGPT while respecting their existing Salesforce permissions. A Tableau plugin offers similar access to Tableau sites, workbooks and metrics. For developers, the official Salesforce DX MCP connects Codex to more than 60 developer tools, such as listing orgs, retrieving metadata, creating snapshots and running tests, and it is hosted and updated by Salesforce. Skills are reusable instruction sets, AGENTS.md files give standing instructions read before work begins, projects group related conversations and files, and team tasks let several people own and manage a task. The author explains three model tiers: Astra, the most powerful and costly, to be used sparingly; Sol, the everyday model for moderately complex work; and Luna, the fast, cheap model for simple tasks. The key advice is to match the model to the task, since a weak model on a complex job can waste tokens without a result.
The article offers admin use cases such as generating project and org documentation, summarizing customer and deal information before meetings, and using Codex with the DX MCP to build metadata, testing in a Scratch Org or sandbox, and deploying only after review. Throughout, the author stresses that AI output must be verified, that AI is an assistant rather than a replacement for skilled Salesforce professionals, and that agentic tools should be given restricted org access, with deployments handled manually. Users of the Salesforce app should also be told that AI can make mistakes, and people should avoid granting AI more access than it needs and check their permission and security setup before connecting tools.
You will learn how to select the correct diagram type for your audience and apply Salesforce updated template libraries to accurately represent current platform capabilities.
Salesforce architects spend much of their time communicating design decisions, and a clear architecture diagram gives teams a shared reference point that replaces long meeting notes and chat threads. Salesforce refreshed its Reference Diagrams, Architecture Gallery templates and Lucidchart shape libraries in June so they reflect Agentforce and Data 360, the renamed Data Cloud. The Cards library now includes preformatted Agentforce components, product names are updated, and new templates cover multi-cloud work coordinated by Agentforce, event-driven agent triggers and data flows with AI decisioning. Font sizes and border contrast were also improved for large-screen reviews, and some interaction process flow diagrams tied to Decision Guides and Fundamentals content were retired. The refresh did not change Salesforce’s five core diagram types, its Lucidchart partnership or its overall approach.
The five core types each answer a different question, so the choice should start with the audience. Capability maps show what business capabilities a solution must provide, without technical detail, and suit executives. Roadmaps add a time dimension for phased delivery and can show technical dependencies in business terms. System landscapes show the systems, products and connections in an estate, which helps with discovery and impact analysis. Solution architectures show how systems communicate and integrate, including authentication and data movement, and are the diagrams implementation teams use most. Interaction process flows show the numbered sequence of steps, agent actions and handoffs over time.
Most substantial projects use several of these diagrams, and they should tell a consistent story across each other. Architects are advised to start from a template in the Reference Architecture Gallery rather than a blank canvas, then adapt it to their scenario. For Agentforce designs, the article recommends splitting concerns across multiple diagrams rather than overloading one, and making human-in-the-loop points and data grounding visible to security, governance and business readers. Diagrams are not a substitute for entity relationship diagrams when data modeling is significant. The article closes by stressing that a good diagram makes the right information easy to understand for its particular audience, not that it contains the most detail.
You will learn how untrusted input can steer Agentforce into exfiltrating data via DNS lookups, and which Einstein Trust Layer controls actually mitigate these risks.
Why read this
You will also get a practical checklist for configuring runtime identities, permissions, and safe workflows.
Research by Zenity demonstrates a prompt injection chain where untrusted text stored in a Web-to-Lead record steers Agentforce to query authorized account data. The injected instructions embed the results in an external hostname, exploiting a Trusted URLs parsing discrepancy that triggers a DNS lookup to exfiltrate information without requiring user interaction.
The Einstein Trust Layer provides several guardrails, including semantic filters, zero data retention agreements, and audit logging, but it does not enforce authorization policies or stop agents from querying records they are already permitted to see. Data masking is currently disabled for agents, and prompt defenses remain probabilistic rather than absolute.
Securing Agentforce requires strict identity and permission hygiene. Administrators must verify whether agents run under employee profiles, dedicated service users, or integration accounts, then restrict object and field access accordingly. Replacing broad query tools with custom Apex actions that enforce user mode and explicit Sharing Rules reduces exposure.
A recommended architecture isolates unauthenticated submissions behind a read-only lead triage agent, followed by human review before downstream agents handle outbound communication. This layered approach prevents poisoned data from reaching internal databases or messaging channels like Slack.
Readers will learn a structured five-step process for auditing and cleaning Salesforce records before deploying artificial intelligence features.
Why read this
The piece explains how to automate ongoing data hygiene using standard administrative tools to prevent model failures.
The article argues that artificial intelligence initiatives in Salesforce consistently fail when trained on unclean data, emphasizing that pattern matching models amplify existing record errors rather than masking them. Common issues include duplicate contacts and leads, incomplete required fields, inconsistent Picklist values, and stale records that cause Agentforce assistants to route cases incorrectly or generate inaccurate summaries.
To address these problems, the author recommends running a comprehensive data audit before approving any artificial intelligence project. This involves generating reports on empty key fields, executing Duplicate Jobs, and manually sampling records to create a data health summary for leadership approval. The cleanup must follow a strict sequence starting with deduplication, followed by populating critical fields, standardizing formats through Validation Rules, archiving inactive records, and enforcing data entry standards at the source.
Sustainable data quality requires moving beyond one-time projects by implementing automated maintenance routines. The author suggests scheduling recurring Duplicate Jobs, distributing weekly exception reports to record owners, and tracking completeness metrics on a dashboard. Once real data ownership is established and the operational layer is secured, Salesforce artificial intelligence capabilities such as lead scoring and case classification can function reliably without undermining user adoption.
Readers will learn the syntax and practical examples for using the JSON Path function in AgentScript to select, range, and filter data from action responses without writing Apex or Flow.
The article introduces the JSON Path function available in AgentScript, explaining how it extracts data from objects and lists using standard expressions. The function takes three arguments: the source variable, the query path, and an optional default value to return when no match is found. All queries return results as a list.
Several practical examples demonstrate how to navigate nested data structures. The author shows how to retrieve a specific field from a single record, use asterisks to pull the same field from every item in a collection, and apply slice notation to grab a subset of records. Each example includes the exact expression and the resulting output.
Filtering logic allows users to narrow down collections based on conditions before extracting values. The piece illustrates how to combine equality checks and logical operators to isolate records matching multiple criteria. The author warns that while filtering works in sandbox environments, official documentation currently omits these expressions, advising caution before deploying them to production.
By Magulan Duraipandian · InfallibleTechieReaders can apply these rules to configure reliable multi-agent routing and avoid common delegation pitfalls.
You will learn how Agentforce Coworker selects which agent handles a request and why only agent descriptions, not subagent instructions, control that decision.
Why read this
Readers can apply these rules to configure reliable multi-agent routing and avoid common delegation pitfalls.
User submits a request to Agentforce Coworker
Coworker cannot complete the request itself
Reads accessible agent and subagent descriptions
Compares request against agent capabilities
Delegates request to matching Employee Agent
Agentforce Coworker routes incomplete requests by evaluating accessible agent descriptions against user queries
Agentforce Coworker acts as a central entry point that delegates incomplete requests to specialized agents like Agentforce Employee Agents. The system evaluates the incoming request against the capabilities defined in each accessible agent and subagent description before making a routing decision.
A critical configuration detail is that Coworker ignores subagent instructions when determining routing. Builders must place all routing-relevant information directly in the agent descriptions to ensure accurate matching. User permissions also filter which agents are available for delegation.
Reliable delegation requires distinct capability statements across agents, explicit coverage of subagents, and verification of user access levels. Testing with varied phrasing helps confirm that the routing logic aligns with actual user requests.
By Jason Fung · Nebula ConsultingThey will also learn about the upcoming November changes to the flex credits model and the new Agentic Identity framework for agent permissions.
Readers will understand how Model Context Protocol servers connect Salesforce to external systems through natural language prompts.
Why read this
They will also learn about the upcoming November changes to the flex credits model and the new Agentic Identity framework for agent permissions.
The article introduces Model Context Protocol servers as a standardized interface for linking artificial intelligence hosts to enterprise systems like Salesforce. It outlines a three-part architecture comprising a host application, a client, and a server that securely exposes tools and resources. This design aims to replace custom integrations by allowing large language models to automatically discover and execute connected capabilities.
Practical examples demonstrate how sales and support teams can retrieve pipeline data or automate cross-platform workflows using simple natural language commands. These scenarios eliminate the need to manually switch between separate applications and navigate multiple forms to complete routine tasks.
Financial and governance impacts are also addressed, noting that agent-driven calls will begin consuming standard flex credits in November. The piece explains the introduction of Agentic Identity to distinguish between standard user operations and scoped agent permissions. Testing environments including Sandboxes and Scratch Orgs remain exempt from these billing changes, allowing teams to evaluate the technology safely before production deployment.
Readers will learn how to configure the Salesforce in Claude plugin, audit permissions for agentic access, and prepare for the November billing model using Flex Credits and agent registration.
Audit Permission Sets and profiles
Clean the fields the skills read
Keep approvals on
Pilot in a sandbox
Name an owner for connections
Five checks to prepare your Salesforce org for Claudeforce and AIforce billing
Claudeforce, the expanded Salesforce and Anthropic partnership announced on August 26, 2026, works in two directions. Claude becomes a reasoning model inside Agentforce and the default model in Slack, while Salesforce reaches into Claude through the Salesforce in Claude plugin. That plugin bundles 37 prebuilt sales skills covering account research, call prep, pipeline review and CRM updates, with Salesforce and Slack connectors. It is in beta for approved orgs on paid Claude plans and requires the latest Sales Cloud Enterprise edition.
On security, sellers sign in with their own Salesforce credentials, so Claude can only do what their permissions allow, and by default it asks for approval before any write. Salesforce Help notes that when a custom action uses a Claude model hosted inside the Salesforce Trust Boundary, data stays inside that boundary, though Einstein Trust Layer data masking is disabled for those agents and zero data retention still applies. The article advises reading that page in full before writing a risk assessment, and it warns that most capability claims come from launch material and should be tested in a sandbox first.
The setup path has four stages. First, the org confirms eligibility and gets approval through the beta sign-up on AgentExchange. Second, a Salesforce admin creates an External Client App for Claude, because Connected Apps are not supported for MCP clients. Third, a Claude Primary Owner or Owner enables the plugin in Organization settings and enters the app’s consumer key and secret. Finally, each member signs in with their own Salesforce account on first use.
The billing changes are targeted for November. Admins register agents, each of which gets its own identity and can hold a narrower Permission Set than a human user. Every successful MCP or API call from a registered agent counts as a Headless Platform Interaction, paid with Flex Credits, though the rates are still TBA and metering applies only to active production orgs, with 30 days’ notice before it starts. Customers who buy on or after September 17, 2026 must register agents at purchase, while existing customers register at renewal. The article does not say how the Salesforce in Claude plugin will be classified under this model.
The article recommends five preparation steps: audit Permission Sets and Profiles, clean the fields the skills read, keep approvals switched on, pilot in a sandbox, and name an owner for connections and consumption. Cloud Odyssey’s own view is that Claudeforce exposes existing CRM data quality problems, and it suggests starting with a health check, connecting surrounding systems, piloting with one team, and keeping model choice open.
Readers will learn how to structure Permission Sets and groups for different AI roles, understand how field-level security applies at runtime, and implement human-in-the-loop controls for autonomous agents.
Generative AI Security Setup
License and Permission Set Allocation
Field-Level Security Inheritance
Agentforce Action Boundaries
Breakdown of the three core pillars for AI governance
The article outlines a structured approach to managing generative AI access by separating feature availability through Permission Set Licenses from functional capabilities via Permission Sets and Permission Set Groups. It defines four core roles, including an AI System Administrator, Prompt Template Author, Standard End-User, and Agentforce Runtime User, emphasizing that bundling permissions into groups prevents security drift when users change departments.
When prompts execute on record pages, Prompt Builder enforces security before data reaches the large language model. The system validates object read access, applies field-level security by nullifying restricted merge fields, and respects Sharing Rules. A practical example shows how a customer support representative without access to a profit margin field receives a blank value, ensuring sensitive financial data never leaves the organization or enters the model cache.
For autonomous execution, Agentforce supports three action modes ranging from full autonomy to requiring explicit user approval. The piece recommends starting with safe defaults that allow read-only lookups while triggering human confirmation for write operations. It demonstrates a human-in-the-loop pattern where an agent drafts an email via a flow, leaving the final review and send capability restricted to a human user.
Finally, the guide provides a deployment checklist covering permission group assembly, field security verification, action boundary configuration, and Einstein Trust Layer settings like zero data retention and data masking to ensure compliance before production rollout.
You will learn how to prevent time zone conversion errors in Agentforce by enabling user profile context, adding explicit LLM instructions, and typing action inputs as ISO 8601 strings.
Why read this
The guide also shows how to structure these elements in an Agent Script that calls a Flow.
The article addresses a common failure mode where Agentforce agents misinterpret local time because Salesforce stores DateTime values in UTC while users communicate in their local time zones. It outlines three required components to fix this: exposing the user profile context, providing explicit reasoning instructions to the large language model, and defining action inputs with the correct data type.
A complete Agent Script example demonstrates an Employee Agent that manages calendar events. The script enables the user profile context to retrieve the current user time zone without asking the user. Reasoning instructions direct the model to apply that time zone for display purposes while omitting offset details from the conversation. Conditional logic gates event actions behind a valid record identifier.
The workflow passes deterministic parameters like account identifiers directly to the Flow, leaving only the start datetime field open for natural language processing. By assigning the lightning__dateTimeStringType complex data type to that input, the agent converts conversational phrases into structured ISO 8601 values before handing them off to the downstream Flow.
By Magulan Duraipandian · InfallibleTechieThe piece outlines a dual-layer strategy combining explicit prompt instructions in the Agent Definition with runtime validation in Lightning Flow.
You will learn how to prevent FIELD_INTEGRITY_EXCEPTION errors when Agentforce updates Restricted Picklist fields.
Why read this
The piece outlines a dual-layer strategy combining explicit prompt instructions in the Agent Definition with runtime validation in Lightning Flow.
When Agentforce processes natural language requests to update Restricted Picklist fields, the underlying large language model often passes synonyms or different casing that do not match the exact API names. This mismatch triggers a FIELD_INTEGRITY_EXCEPTION during Flow execution.
The author recommends a dual-layer validation approach to solve this. The first layer occurs at the Agent Definition stage, where developers configure action parameters using structured instructions. These instructions whitelist exact values, define case sensitivity, map common synonyms to valid API names, and direct the model to request clarification instead of guessing invalid inputs.
The second layer enforces checks within the backend Lightning Flow before any record update occurs. By combining strict prompt guardrails with explicit flow logic, practitioners can ensure reliable data ingestion while maintaining the integrity of Restricted Picklist fields.
You will learn how to structure declarative JSON widgets, bind them to Apex data using Custom Lightning Types, and configure Agentforce to render interactive cards instead of plain text.
Write an Apex invocable method to return data
Package the layout into a UiWidgetBundle
Link output shape to widget via renderer config
Update Agent Script to mark data displayable
Test layouts in HXL Playground before deploy
Workflow for building and testing interactive widgets with HXL
The post introduces the Headless Experience Layer (HXL), part of Salesforce’s Headless Toolkit, which lets developers define an interactive widget once in declarative JSON and have it render natively in Agentforce and in any MCP client that supports MCP Apps. Instead of an agent replying with plain text, the same action can return a branded card that looks and behaves consistently across channels. Widgets are composed from reusable components rather than built as Lightning Web Components or React apps, and they only display what the underlying Apex action returns, so existing sharing and field-level security still apply. HXL rests on three concepts: components, which are surface-aware UI primitives; widgets, which combine components into a use case; and Custom Lightning Types (CLTs), which describe the shape of the data and whose renderer tells the platform which widget draws it and how fields map onto its attributes.
The authors illustrate the approach with a review card from Pronto, their fictional food-delivery sample app. The card is built from four pieces: a global Apex invocable action (GetCustomerReviewsAction) that returns review data; a widget whose files live in a UiWidgetBundle, namely a registration XML file, a JSON composition built from tile blocks with a forEach loop for list items, and an optional schema; a CLT that binds the action’s output to widget attributes using {!$attrs} and similar paths; and an agent output or MCP tool that marks the output as displayable. In Agentforce, the Agent Script sets is_displayable to True, and the model decides when to show the card, which in the authors’ testing usually happens on the first question of a fresh conversation. For MCP clients such as Claude and ChatGPT, two nested CLTs are needed because the tool output is wrapped in an envelope; only the outer type carries the renderer, and an MCP server entry publishes it as a UI resource that the tool references. The HXL Playground offers a browser-based way to preview layouts with sample data, though previews may differ from the live experience.
The post closes with getting started steps: enable Headless Experience Layer (Beta) under Feature Settings in Setup, use API version 67.0 or later, clone and install the Pronto app, and optionally use the open-source Salesforce Skills library to generate widgets, CLTs and MCP types with an AI agent. It also points to a hands-on workshop, and it presents HXL as a way to deliver consistent interactive UI across agent surfaces with less integration code.
You will learn how to enforce security and accountability in Agentforce deployments using deterministic guardrails, strict memory isolation, and defined human escalation points.
Why read this
The piece outlines practical architectural patterns to prevent cascading failures and prompt injection across multi-agent workflows.
The article explains that moving to interoperable multi-agent systems requires shifting from perimeter-based security to a Zero Trust model where every interaction is continuously verified. Because large language models can correctly identify risks yet still execute harmful actions, the author recommends combining probabilistic reasoning with hard-coded, deterministic guardrails that operate outside the agent’s internal loop.
To prevent context collapse and sensitive data leakage, the piece warns against shared memory pools that create unstructured data puddles. Salesforce addresses this by assigning an owner tag to every piece of memory, ensuring strict isolation between users and assistants. Access is further controlled through session-based security checks and filters that block sensitive information from reaching external tools.
Finally, the author addresses the tension between full autonomy and necessary oversight. While constant human intervention defeats the purpose of agentic automation, clear escalation thresholds must be established. Agents should pause for human review during significant financial transactions, low-confidence decisions, detected prompt injection attempts, or repeated failure loops to maintain accountability without sacrificing scalability.
By Cody Snell · Salesforce NewsThe piece also outlines the tools available for auditing, testing, and maintaining human oversight over autonomous agents.
Readers will learn how Agentforce separates language reasoning from business actions by routing decisions through Flow, Apex, and Agent Fabric.
Why read this
The piece also outlines the tools available for auditing, testing, and maintaining human oversight over autonomous agents.
Agentforce divides agent operations into two distinct layers to balance capability with control. A generative layer handles natural language processing and reasoning, while a deterministic layer manages all consequential actions.
Consequential decisions are routed through established Salesforce automation and development tools like Flow, Apex, and Agent Fabric. This ensures every action adheres to predefined business policies, permissions, and escalation paths rather than relying solely on model predictions.
The system maintains accountability through the Atlas Reasoning Engine, which requires agents to justify their steps, and a comprehensive audit trail that logs both agent and human activity. Continuous evaluation is supported by the Testing Center for bias detection and the Trust Layer for input and output safety.
By Marlene Guerra-Reeve · Salesforce ArchitectsThe piece also outlines updated platform limits, new Agentforce orchestration patterns, and governance tools that shape long-term org architecture.
You will learn which authentication methods retire by early 2027 and how to migrate integrations to secure alternatives.
Why read this
The piece also outlines updated platform limits, new Agentforce orchestration patterns, and governance tools that shape long-term org architecture.
Winter ’27 Release
Mandatory security enforcements
Capacity and automation updates
Agentic architecture design
Governance and observability
The Winter ’27 release guides architects through four key architectural focus areas
The Winter ’27 guide presents the release as a set of coordinated architecture decisions across security, capacity, agentic design and governance. It recommends starting with operational risk, then judging whether new platform capabilities help existing configurations scale and fit the longer-term architecture roadmap.
The security section focuses on deadlines. Production refresh tokens expire after 30 days of inactivity starting November 4, 2026, which can break low-frequency integrations. The OAuth 2.0 device flow is restricted from November 30, 2026, and the username-password, user-agent and hybrid user-agent flows are retired on February 20, 2027. Salesforce to Salesforce retires in Spring ’27, and cross-org adapter authentication must move to Named Credentials. Connected Apps lose support by Summer ’27, so teams should move to External Client Apps, which are closed by default. The guide advises inventorying integrations, defining each trust boundary, and choosing replacements that will not face further restriction.
The capacity section covers higher limits and their risks. Synchronous Apex heap rises from 6 MB to 10 MB and asynchronous heap from 12 MB to 25 MB, so workarounds may be simplified. Elastic Async Apex Jobs (Beta) now covers batch jobs as well as future and Queueable jobs, with extra capacity capped at the lower of the licensed limit or 2 million jobs, and should be tested in non-production first. Flow improvements may make Apex built around older constraints unnecessary. Retained manual shares on ownership changes can replace recreation logic, but processes that depend on ownership changes removing access need review.
For Agentforce, Multi-Agent Orchestration is generally available and should be treated as a design-time topology decision. The API Catalog should be governed as the control point for the MCP servers and APIs agents can call, and Data 360 hierarchies should be planned as a data-architecture task. Governance tools include Security Health Review, Scale Center, MCP Server Monitoring (Beta) and Security Mesh. Each has edition, license or support-plan limits, and the guide names fallbacks such as Health Check, debug logs and existing observability tools. The guide closes by recommending an architectural decision record for each significant change.
Readers will learn the exact configuration blocks needed to enable voice in an Agent Script agent and how to adjust system instructions for spoken delivery.
Why read this
The guide also covers org prerequisites and deployment steps to avoid common speech-to-text pitfalls.
Verify Agentforce Voice is active
Insert language, telephony, and modality blocks
Rewrite instructions for spoken delivery
A streamlined workflow to voice-enable an Agent Script agent
Before modifying any code, administrators must verify that Agentforce Voice is active in the organization. Once enabled, adding voice capability follows a straightforward two-part workflow that keeps the core agent logic intact while routing conversations through a telephony channel.
Developers need to insert three specific configuration blocks into their Agent Script files. These blocks define the supported language, establish the telephony connection, and select the outbound voice model along with its persona. The nested settings ensure the correct speech synthesis engine handles both incoming audio transcription and outgoing responses.
Because listeners cannot reread text, the system prompts require careful rewriting. Replies must be concise, free of markdown or raw code snippets, and formatted so symbols are spoken as words. The guide emphasizes training the agent to silently correct common speech-to-text errors, such as mishearing technical terms, before providing a final response.
By Adam White · Salesforce Admins BlogYou will also understand upcoming capabilities like element mocking, test coverage tracking, and Agentforce powered troubleshooting.
You will learn how to enable and use the new Test Mode beta to save, reuse, and automate Flow validation without leaving the builder.
Why read this
You will also understand upcoming capabilities like element mocking, test coverage tracking, and Agentforce powered troubleshooting.
Traditional Approach
Debug button only for troubleshooting
Testing and debugging require separate actions
Manual checks lack reusable configurations
Cluttered design canvas during validation
Test Mode Workspace
Dedicated view replaces Debug button
Merges debugging and automated testing
Saves runs as reusable manual test scenarios
Converts manual tests to regression tests with assertions
How Test Mode consolidates Flow debugging and automated testing
Salesforce has released a beta version of Test Mode, a dedicated workspace that replaces the traditional Debug button in Flow Builder. This update merges debugging and automated testing into a single interface, requiring administrators to enable the feature through Process Automation Settings before it becomes available for Record-triggered and autolaunched flows.
The new workspace allows builders to save execution runs as reusable manual test scenarios. These saved configurations preserve triggering records, input variables, and mocked outputs. Administrators can now supply static record identifiers for poorly searchable objects and populate primitive collections directly in the test panel. Once validated, these manual scenarios can be transformed into permanent regression tests by attaching expected results.
Test Mode also introduces element mocking, which simulates outputs for subflows and external actions to keep testing isolated from live endpoints. The roadmap includes Winter ’27 enhancements such as visual test coverage tracking on the canvas and Agentforce powered capabilities. These future features will synthesize transaction context to diagnose cross automation failures and automatically generate comprehensive test scenarios with isolated data silos.
Salesforce Developers BlogThe guide demonstrates how structure-aware splitting preserves table headers and speaker labels, resulting in more accurate Agentforce responses.
You will learn how to deploy Python-based Code Extension functions to override default chunking in Data 360 search indexes.
Why read this
The guide demonstrates how structure-aware splitting preserves table headers and speaker labels, resulting in more accurate Agentforce responses.
The article argues that poor chunking, not the language model, is often the real cause when an Agentforce agent misses details from a PDF or misreads a conversation, because retrieved snippets lose their context before the model sees them. Native Data 360 chunking (section-aware and semantic passage extraction) works well for standard content, but it struggles with complex multipage PDFs, dense tables and multispeaker transcripts when character or token-based splitters are used. Code Extension functions let developers deploy sandboxed, stateless Python chunking logic inside the Salesforce trust boundary, authored with the Data Custom Code SDK, deployed via the Salesforce CLI or UI, and wired into search index creation. The authors caution that their regex and pattern-based examples are illustrative happy-path code, not production-grade, and can produce false positives and negatives.
The piece tests three scenarios, comparing native chunks with custom ones. In a quarterly financial report, native splitting left numbers stranded without their column headers, making a growth-rate question unanswerable; a structure-aware function that detects table boundaries and repeats headers in sub-chunks lets the agent give a precise segment comparison. In a recorded escalation call with five speakers, native chunking produced unattributed walls of text, while a sliding-window function over speaker turns (window of 6 turns, stride of 3, capped at 1,500 characters) kept questions with their answers and preserved speaker names and timestamps, so the agent could identify a contractual downtime commitment. In a regulated-sector document, native chunking exposed SSNs, card numbers, emails, phone numbers, medical record numbers and other identifiers in the vector index; a regex pass before chunking masked the standard formats, though proprietary identifiers such as medical record, payer member, case and token numbers passed through until organization-specific patterns were added. The conclusion is that Code Extension is an escalation path for complex data rather than a replacement for native chunking, and it points developers to the documentation, the Code Extension setup in Data 360 and a video playlist to get started.
Salesforce Developers BlogThe piece also explains how to register the external data source programmatically using the Headless 360 MCP Server instead of manual setup steps.
You will learn how to use the platform-salesforce-connect-adapter-generate skill to automatically create DataSource classes for any REST API.
Why read this
The piece also explains how to register the external data source programmatically using the Headless 360 MCP Server instead of manual setup steps.
Custom Salesforce Connect Apex adapters require implementing DataSource.Provider and DataSource.Connection interfaces, which traditionally demands significant Apex expertise and careful handling of field types, pagination, and error contracts. The article introduces the platform-salesforce-connect-adapter-generate skill, an open-source capability that grounds coding agents in this exact framework so they produce syntactically correct and contract-compliant code on the first attempt.
Using a natural language prompt, a developer can instruct an agent like Claude Code or Agentforce Vibes to generate both adapter classes, map json fields to correct datasource datatypes, enforce required ExternalId columns, and wire Named Credentials without hardcoding secrets. The post demonstrates this with a public rail api example, showing how the generated Connection class handles query context and returns a properly structured TableResult.
After deploying the Apex classes via the Salesforce CLI, the article explains how the Headless 360 MCP Server exposes configuration operations as programmatic tools. This allows the same agent to create the external data source definition through an api call rather than navigating the Setup wizard. The author notes that Winter ’27 will expand this approach to cover the full lifecycle of external data sources and standard adapter extensibility.
By Archana Kumari and Yushu Yao · Salesforce EngineeringThe piece explains the current debugging workflow and outlines upcoming capabilities for automated root cause analysis and remediation.
You will learn how Agentforce Health Monitoring unifies fragmented telemetry to detect silent availability failures and reduce alert latency to under two minutes.
Why read this
The piece explains the current debugging workflow and outlines upcoming capabilities for automated root cause analysis and remediation.
Agentforce Health Monitoring addresses the gap where traditional dashboards show healthy status while users actually receive no end-to-end response. The system tracks over sixteen built-in metrics including error rates, escalation rates, engagement, and latency, with plans to add cost, time-to-first-token, and RAG quality signals. Its primary goal is proactive visibility that connects alerts directly to the relevant session context.
The engineering team solved a major fragmentation problem by consolidating signals scattered across five or six separate systems. By converting data ingestion to streaming and simplifying query complexity, they accelerated metric evaluation. This optimization reduced the time from a threshold breach to administrator notification from approximately twenty minutes to several minutes, targeting an investigation start time under two minutes.
Operational workflows now emphasize actionable debugging rather than simple detection. Administrators can drill down from an alert to examine specific reasoning steps, tool calls, or flow configurations that caused a failure, and they can define custom thresholds like token usage limits. Looking ahead, the roadmap includes runtime insight agents to suggest fixes and fully automated remediation pipelines that apply approved solutions without manual intervention.
By Scott Nyberg · Salesforce EngineeringYou will also see the architectural tradeoffs used to achieve sub-two-hundred millisecond response times for Agentforce interactions.
Readers will learn how the engineering team partitions and indexes Data 360 data graphs to resolve complex customer identities while maintaining strict data isolation.
Why read this
You will also see the architectural tradeoffs used to achieve sub-two-hundred millisecond response times for Agentforce interactions.
The engineering team built Data 360 data graphs to solve the context gap for Agentforce by unifying fragmented customer data across accounts, entitlements, and products. Instead of running multiple queries at runtime, the system pre-aggregates relationships into cohesive data products that agents can call directly.
Resolving customer identity required a partitioned architecture that keeps the broader identity graph separate from customer success views. This ensures that prospect data and information belonging to different tenants remain strictly isolated while still supporting complex many-to-many relationships.
Performance was optimized by analyzing access patterns, designing smaller multi-graphs, and building targeted indices to avoid full table scans. The team shifted from static data models to flexible structures that support semantic search and unpredictable agent queries, ultimately achieving median response times under two hundred milliseconds without dedicated autoscaling infrastructure.
Readers will learn how to use the Agentforce Vibes IDE to automatically inspect Custom Field metadata, identify missing or conflicting descriptions, and apply approved updates without navigating Setup pages.
Preparing metadata for an Agentforce agent requires reviewing objects, fields, and flows rather than cleaning up the entire org. The article introduces the Agentforce Vibes IDE as a conversational workspace where administrators can query and evaluate configuration data efficiently.
By running targeted prompts in plan mode, Vibes retrieves field metadata and flags Custom Fields with ambiguous labels, missing descriptions, or mismatched business concepts. The system generates evidence-based findings and drafts proposed descriptions while strictly avoiding unsupervised modifications.
Administrators review the AI suggestions, approve valid updates through the interface, and separate genuine cleanup candidates from fields that simply require business clarification. The workflow concludes with bulk updates via CSV attachment or individual conversational commands, allowing teams to maintain human oversight while accelerating metadata preparation.
You will learn how to implement the Headless Experience Layer to design interactive AI workflows that render consistently across external agentic surfaces.
Why read this
The session also covers practical guidance from Salesforce experts through a live question-and-answer format.
The presentation introduces the Headless Experience Layer as a tool for developing interactive artificial intelligence workflows. By leveraging this layer, developers can create a single workflow definition and deploy it across various agentic environments without rebuilding the interface for each target.
The approach emphasizes delivering consistent and rich user experiences natively on third-party platforms such as Slackbot, ChatGPT, and Claude. This allows teams to maintain a unified design language while extending their Salesforce AI capabilities beyond the standard interface.
The video concludes with a live expert session where attendees can submit technical questions about implementation patterns, configuration requirements, and best practices for scaling these agentic interfaces.
Salesforce Admins on YouTube, videoThe walkthrough demonstrates how an activated service agent handles a customer interaction and automatically creates a case.
You will learn the step-by-step configuration required to enable Agentforce Voice, including tuning voice parameters, connecting telephony and SMS, and routing calls through Omni-Channel flows.
Why read this
The walkthrough demonstrates how an activated service agent handles a customer interaction and automatically creates a case.
The video provides a guided tour of the initial configuration steps for Agentforce Voice. It begins by navigating the voice settings interface where administrators can select from available stock voices and adjust performance parameters such as speed, similarity, stability, and pronunciation.
Next, the walkthrough covers the integration requirements for communication channels. It explains how to configure enhanced chat and microphone capabilities, set up telephony and SMS routing, assign phone numbers, and connect the system to Omni-Channel flows for proper call distribution.
The final segment demonstrates the activation process for an Agentforce service agent. Once enabled, the video shows a live customer conversation regarding a power adapter, illustrating how the voice agent processes the inquiry and automatically generates a new case record in the system.
You will learn which three integration APIs form the foundation of Salesforce connectivity and how they support emerging AI agent workflows.
Why read this
The piece also outlines the current certification roadmap and upcoming MuleSoft credential changes.
The video argues that artificial intelligence agents interact with the platform through application programming interfaces rather than user interface clicks, making integration expertise increasingly vital. It identifies three foundational tools that practitioners should master first.
The REST API handles standard create, read, update, delete operations and data queries. The Bulk API processes large scale jobs involving fifty thousand or more records. Platform Events combined with the Pub/Sub API enable reliable publish subscribe messaging between systems.
The Certified Platform Integration Architect certification path serves as a stepping stone toward System Architect and CTA designations. Two MuleSoft credentials will retire on February 1, 2027 while the product line continues to operate. Salesforce now classifies Headless 360 capabilities under Agentforce revenue metrics, reporting annual recurring revenue exceeding one point five billion dollars.
You will see how one Custom Metadata Type can feed formulas, Validation Rules, Flow, Apex and Agentforce actions, and where those references stop working.
Typed into each tool
Thresholds in formulas
Defaults in Flows
Feature switches in Apex classes
Each change means finding every use
Custom Metadata Types
One deployable home for values
Travels through source control
One record per region plus Default
Read via $CustomMetadata reference
One deployable home replaces values typed into each formula, Flow or Apex class
The article argues that developers often hard-code business values such as thresholds, defaults, feature switches and mappings into formulas, Flows and Apex without noticing, which makes later changes hard to trace. Custom Metadata Types offer a central, deployable home for these values. Unlike Custom Settings or Custom Objects, which hold data, Custom Metadata holds configuration that ships with application code through source control and CI/CD. The author illustrates this with a Deal_Policy__mdt type holding a shared maximum discount and regional records for large-deal amount, default discount and approval threshold, selected by region name.
The piece then maps where references work. Formula Fields, Validation Rules and field defaults can use a three-part reference (type, record name, field), but the formula must name a fixed record, so it cannot pick a region from opportunity data. Long text area fields cannot be referenced, and the formula editor does not list Custom Metadata fields for defaults, though typing the reference still works. Flow can query the type with Get Records, match a region, and fall back to the Default record, and it can also use the literal reference. Apex uses getInstance with a similar fallback. Custom Permissions are kept separate, since they govern what a user may do while Custom Metadata governs the values.
Agentforce cannot read $CustomMetadata references directly, so the workaround is an invocable Apex action that loads the policy and returns the values, which the Agent Script maps into variables before answering. Lightning App Builder component visibility does not accept Custom Metadata references. On record pages a Formula Field can bridge the value, though that adds a field, and App and Home pages must read the data in Apex, through @wire, or via Dynamic Interactions.
To assess impact, the article recommends Setup’s Where is this used? option or a Tooling API query of MetadataComponentDependency, which lists the Apex classes and Validation Rules that depend on a field. It also notes that an attempt to build an LWC editor that showed these dependencies from Apex was complicated by the authentication setup REST calls require. Finally, it outlines platform limits: 200 types per org (350 with certified managed packages), 100 fields per type, and a 10 million character budget where each text area reserves 255 characters regardless of use. Process Builder allows 15 Custom Metadata formula references per process. The author concludes that teams should treat business values as configuration, centralize them, and keep track of where each reference works and where it does not.