The independent daily for Salesforce admins, developers and architects

Curated by Abhinav (opens in a new tab)

Must-read

Six practices for taking Tableau MCP agents from prototype to production (opens in a new tab)

You will learn how to prepare a Tableau data model for agents, scope their tools and data, and build a test and monitoring harness before agents reach end users.

Why read this

The post draws on a regulated-industry customer deployment.

  1. Prepare the data model
  2. Define the agent's role
  3. Follow least privilege
  4. Load metadata into the prompt (optional)
  5. Pre-build queries for known questions
  6. Build evaluation and monitoring
Six practices for moving a Tableau MCP agent from prototype to production, in order

The post describes a large enterprise customer in a regulated industry that moved from Tableau dashboards to custom agents built on Tableau MCP. Off-the-shelf Tableau agents were too broad for the customer, who needed specialized workflows, agents that could act on results, embedding in a purpose-built application, and fine-grained control. Custom agents bring more need for testing, governance and monitoring, so the authors set out six practices.

The first is to prepare the data model. Business logic should live as close to the data as possible: calculated fields for fixed logic, Tableau Knowledge business preferences or field descriptions for logic shared across agents, and agent system instructions for logic specific to one agent. Teams should also remove duplicate fields, describe fields with units and caveats, name them in business terms, hide irrelevant fields and certify the data sources. The TDS Edit API, available in Tableau Cloud from October 2026 and Tableau Server 2026.3, lets teams add field descriptions in code.

The second is to define the agent’s role by answering what problem it solves, which domain it serves, what it can and cannot answer, and how it should respond. The answers shape its data, tools and system prompt. Tableau MCP now supports embedded data sources in 2026.3.

The third is to apply least privilege. The authors removed tools the agent did not need, starting with list-datasources, and pinned the agent to an approved data source ID. Tool scoping is set through environment variables on self-hosted deployments or site settings on hosted Tableau Cloud, and embedded data sources are scoped by project or tag.

The fourth, optional, practice is to load metadata into the system prompt at session start. This removed the get-datasource-metadata call and cut response time by almost 50 percent. The authors warn that this suits agents with one or two data sources and that stale metadata is a risk if schemas change often.

The fifth is to pre-build queries for frequent questions and expose them as custom tools, so the model only explains results. The authors advise against chasing perfect accuracy for open-ended questions, and suggest dashboards for figures that must be exact.

The sixth is an evaluation and monitoring framework: a question bank with correct answers, including refusals, run against each prompt, model and setting version, with LLM-as-a-judge grading for less deterministic answers, release-style versioning, production monitoring of latency, tokens and failures, and a regular review that adds new questions. The authors recommend an established agent observability platform, and they name LangSmith as an evaluation tool they used.

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

Worth reading?

Recommended

Deterministic gates let an AI agent approve production changes in seconds (opens in a new tab)

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.

  1. Verify approver identity and role
  2. Check linked passing QA test run
  3. Confirm pull request and approval trail
  4. Route to human if any gate is unverified
  5. 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.

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

Worth reading?

Must-read

Claude becomes Slack's default AI, with two Admin-Controlled experiences (opens in a new tab)

You will learn how Slackbot and Claude Tag differ in access, billing and admin control, and what to set up before users start tagging Claude.

Why read this

The piece gives a practical rollout checklist for Salesforce admins.

Channel or group DM

  • Uses tools set up for the channel
  • Runs under Claude's own identity
  • Billed to your organization

One-to-one DM or AI panel

  • Uses the user's own Claude account
  • Uses that user's own connectors
  • Billed to that user's account
Where a user messages Claude decides whose access and billing apply

Claude is now the default model for Slack, powering Slackbot and supporting team work through Claude Tag. The two experiences work differently and each has its own admin controls, so the article sets out what each does, who manages it, and what to check before users begin tagging @Claude.

Slackbot needs no installation. Recent August 2026 upgrades include Big Mode for drafting long documents, Deep Research that returns cited reports from org data and the web, Skill Sets that can be shared and assigned to groups or channels, a Skills Admin Dashboard showing usage, and a Tasks tab for recurring routines. Feature availability depends on rollout timing, licensing and extra license requirements, and compute-heavy Advanced Features are limited at Enterprise+ with 30 days’ notice before any new limits.

Claude Tag, Anthropic’s product, places Claude in channels as a shared teammate, replacing the older Claude in Slack app. It is in beta and requires a Claude Team or Enterprise plan. Whose access it uses and who pays depends on where the user messages it: channels use the tools set up for that channel and bill the organization, while one-to-one DMs use the user’s own account. Setup needs a Slack workspace admin to install the app and a Claude Owner to pair the workspace and set spend limits. Owners control access by workspace or channel, guest channel access (restricted by default), spend caps with alerts at 75% and 90%, and auditing of scheduled work and memory on the Activity page. Slack conversations are kept apart from Claude chat history and deleted within 30 days of disconnecting.

The article closes with a rollout checklist: confirm the roles, pilot a low-risk channel, scope connections by channel, set spend caps first, keep guest access restricted, check the Slack plan, review Skill Sets, and teach users when to use a channel versus a direct message.

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

Worth reading?

Recommended

Staging an AI agent's Salesforce access in three permission levels (opens in a new tab)

You will learn a staged way to grant an AI agent access to Opportunity data: read first, then propose tasks, then write a few fields.

Why read this

You will also see how the staging exposes data gaps and undocumented exceptions before any record changes.

  1. Level 1: read Opportunity and activities
  2. Level 2: propose Tasks for the owner
  3. Level 3: write a few fields
The agent gains write access only after each lower level works

The author describes an AI agent that reviews Salesforce Opportunities with no activity for 30 days, checks recent interactions and prepares follow-up actions. The design question is what the agent is allowed to do, and the author splits this into three permission levels that the agent moves through only once the level below works.

At level 1 the agent only reads Opportunity, its activities and OpportunityHistory. It runs under its own integration user with a Permission Set limited to the objects and fields it needs, and any tool layer such as MCP exposes read tools only. Every query is logged with its filter. This level shows whether no movement is defined well, since LastActivityDate, stage changes in OpportunityHistory and LastModifiedDate give different lists, and LastModifiedDate also moves when a Flow, integration or bulk load touches a record.

At level 2 the agent proposes rather than edits, creating a Task for the Opportunity owner with the suggested next step, WhatId set to the Opportunity, OwnerId set to the owner and a subject prefix that marks it as agent-written. A person decides what happens. This level reveals exceptions, such as deals deliberately paused, which the agent cannot know unless they are stored in a field, and data gaps, such as calls logged outside Salesforce. The author suggests counting open Opportunities with no LastActivityDate and fixing the data before moving on.

At level 3 the agent writes a few fields, such as a next step or follow-up date, with field-level security keeping the rest read-only. Exceptions are encoded in the query, for example skipping records with a future resume date, and changes are tested in a sandbox with realistic data. Because the agent has its own user, LastModifiedById and field history separate its changes from people’s. The author’s point is that a wrong filter at level 3 corrupts every matching record at once, so the staging keeps mistakes cheap.

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

Worth reading?

Recommended

Agent Optimizer guides Agentforce agents through build, test, fix and improve stages (opens in a new tab)

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.

  1. Forming: Build the agent and pass custom-scored tests
  2. Storming: Rank production problems across real sessions
  3. Norming: Trace root cause and draft a fix
  4. 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.

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

Worth reading?

How Salesforce Guardian's AIforce security tools govern admin and agent access (opens in a new tab)

You will learn how Salesforce Guardian is organised into three pillars and what the new Compliance Agent, Security Mesh and MCP Security beta each do.

Why read this

You will also get a short set of practices for moving from reactive to proactive security.

Salesforce Guardian

  • Data Security
  • Data Compliance
  • Data Resilience
Salesforce Guardian is built on three pillars, each with its own products

Salesforce describes security as a shared responsibility. It provides the foundational platform security, admins configure the built-in controls such as multi-factor authentication, IP allowlisting and Permission Sets, and Salesforce Guardian sits on top as a portfolio of enterprise security, privacy and data protection products. The article frames this as three layers: Foundationals, Configurables and Enhanceables.

Salesforce Guardian rests on three pillars. Data Security covers Shield, for encryption, event monitoring and audit trails, and Security Center, for a single view of posture across orgs. Data Compliance covers Privacy Center, for retention and privacy rights requests, and Data Mask & Seed, for protecting sensitive data in sandboxes. Data Resilience covers Backup & Recover, for restoring lost or corrupted data, and Archive, for keeping the org lean while retaining what compliance requires.

The article names three AIforce security enhancements. Compliance Agent, part of Privacy Center, scans core metadata to set a compliance baseline and produce a score tied to regulatory goals, with actionable remediation plans. Because it relies on retrieval-augmented generation, the author stresses that grounding data must be classified, for example under GDPR, HIPAA or other PII categories, or the agent cannot tell public data from restricted data. Security Mesh, part of Security Center, normalizes signals from partners such as Okta and CrowdStrike and adds detections such as Impossible Travel. MCP Security, currently in beta, scans external MCP servers at registration and assigns Low, Medium or High risk scores before agents can reach them.

For implementation, the article recommends adopting a Zero Trust framework and the Principle of Least Privilege for both human and agent users, and setting up escalation paths for high-risk transactions to handle false positives and any human-in-the-loop regulatory requirements.

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

Worth reading?

Carter, a shopper agent for B2C Commerce storefronts built on Agentforce (opens in a new tab)

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.

  1. Shopper asks in natural language
  2. Agentic Commerce Search reads the intent
  3. Carter routes to a subagent
  4. 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.

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

Worth reading?

Must-read

Building Custom Objects and Permission Sets with the Salesforce Development Plugin for Claude Code (opens in a new tab)

You will learn how to set up the Salesforce Development Plugin in Claude Code, prepare an org with the metadata-experts and salesforce-api-context MCP Servers, and generate a Custom Object, Permission Sets and a Lightning page as metadata.

Why read this

You will also see why the older Salesforce DX MCP Server is being retired and why deployments should stay with humans.

  1. Create the DX project
  2. Build the Custom Object and fields
  3. Build the Permission Sets
  4. Build the Lightning page
  5. Package the metadata for a human to deploy
The main stages of building metadata with the plugin in the worked example

The article explains how the Salesforce Development Plugin for Claude Code differs from other tools with similar names. It groups Skills, the Salesforce CLI and hosted metadata servers into one toolset, while the Salesforce DX MCP Server reaches end-of-life on November 2, 2026, and Salesforce in Claude is aimed at end users rather than builders. The author lists the prerequisites: Node.js, Python, the Salesforce CLI and Claude Code, with a Claude plan that includes Claude Code. The org must have the MCP Servers page under Integrations and API Catalog used to enable the metadata-experts and salesforce-api-context MCP Servers.

The walkthrough then installs the plugin with the claude plugin install command and runs the setup command to check the org connection. The author builds a worked example, The General Store, using prompts that create a DX project, an Equipment Loan Custom Object with picklists, a lookup and a long text field, two Permission Sets, and a Lightning Record Page. He reviews the generated XML to confirm the read, create and edit permissions match the requirements.

The piece closes with advice on safety. It recommends building in a sandbox, Developer Edition org or Scratch Org, keeping deployments in human hands, and giving the agent specific field names and permissions because the model is trained on generic data.

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

Worth reading?

Recommended

A four-bucket Kit of 100 prompts for Admin work with Agentforce Vibes (opens in a new tab)

You will learn how the Admin Accelerator Kit's four prompt buckets (Understanding, Configuring, Troubleshooting, Documenting) are meant to be used, and which prompts to run first in a sandbox.

Why read this

You will also see how the buckets chain together on a real change, such as converting a text field to a picklist.

  1. Understanding: map what the org already does
  2. Configuring: plan, then build the change
  3. Troubleshooting: diagnose what breaks
  4. Documenting: record the change and the why
The four prompt buckets are meant to be used in sequence on a single change

The post introduces a set of 100 ready-made prompts for everyday admin tasks, presented at a Dreamforce 2026 session on Agentforce Vibes. The prompts are hosted as a markdown file in the Admin Accelerator Kit on GitHub, and readers can simply browser-copy them. They are organized into four buckets of five categories with five prompts each, and placeholders in angle brackets must be replaced with real API names. The authors note the prompts also work with other agents connected to a Salesforce org through MCP.

The author advises starting in a sandbox or Developer Edition org, especially for Configuring prompts, because Understanding and Documenting prompts mostly read metadata while Configuring prompts change it. Understanding prompts help map objects, Flows, permissions and business processes, and impact-analysis prompts help check what breaks before a field change. Configuring prompts range from “How do I” questions that yield click paths to “Create” and “Write” prompts that generate Flow or Validation Rule metadata for review before deployment.

Troubleshooting prompts cover Flow errors and permission problems, with the advice to paste the full fault email along with record IDs and the affected user. The kit also addresses conflicting automations that silently revert field values. Documenting prompts produce data dictionaries, release notes, deployment checklists and, most importantly, a record of why a rule was configured as it was.

The post closes by showing the buckets chained together on a Region picklist change, and invites feedback and contributions to the kit’s repository.

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

Worth reading?

Writing clearer prompts for agents when you administer Salesforce (opens in a new tab)

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.

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

Worth reading?

Must-read

Setting claude's read and write limits in Salesforce through tool restrictions (opens in a new tab)

You will know how the Sales Cloud in Claude plugin reaches Salesforce, why user permissions set what Claude can read, and how the Dispatch tool restriction setting controls whether Claude can create or update records.

Why read this

You will also have a staged rollout plan with a pre-pilot permission review.

  1. Review permissions before the pilot
  2. Set Dispatch to Deny for read-only
  3. Move to Needs Approval for writes
  4. Use Always Allowed only as last step
Salesforce recommends stepping from read-only to approval-gated writes in this order

Sales Cloud in Claude gives sellers a sanctioned way to ask Claude about their Salesforce accounts. The connection runs as the seller, using their own permissions, against live Salesforce data. The Sales Cloud in Claude plugin, built by Salesforce and Anthropic, bundles 37 sales skills, the Salesforce MCP connection and a setup skill that tailors the plugin to each user’s role. The plugin is in beta and requires an enterprise agreement with Anthropic and Sales Cloud licenses.

The plugin works through the standard Salesforce Hosted MCP Server, which exposes Discover, Describe, Dispatch read-only and Dispatch tools. A Salesforce Admin sets up the server and an External Client App, and the Claude admin configures the connector, sets tool restrictions and decides who gets access. When a seller signs in through OAuth, requests run with that user’s credentials, so field-level security and Sharing Rules apply. Reads need no approval, while writes depend on the Dispatch setting.

Because the hosted server has no generic system user, a user’s object permissions, field-level security and Sharing Rules define what Claude can reach. Those permissions were designed for a human, so broad grants such as View All and Modify All may give Claude more than the job needs. Data Claude reads is also sent to the connected model, which makes the review a data-sharing decision as well as a security one.

The Dispatch tool restriction, found under Organization Settings > Connectors, has three options: Needs Approval, which Salesforce recommends as the steady state; Always Allowed; and Deny, which keeps Salesforce read-only. Dispatch can also call deletes directly even though no skill deletes, so Deny or Needs Approval matters. Salesforce suggests a staged approach: clean up permissions before a pilot, agree the Dispatch setting with the Claude admin, then pilot with a small group and review early approvals. Record each decision in an architectural decision record.

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

Worth reading?

How Salesforce built ITSM Predictive models before real Customer Incident Data existed (opens in a new tab)

You will learn how the team generated synthetic incident data, validated models using scenario tests instead of accuracy alone, and shipped a reusable Data 360 training and scoring pipeline that trains per customer.

  1. Sync incidents and milestones into DMOs
  2. Daily transform labels milestone violations 0/1
  3. Einstein on Data 360 trains XGBoost classifier
  4. Scheduled batch writes scores to score DMO
  5. AI Accelerator card shows score on incident
How the template turns customer incident history into scored predictions on the incident record

Salesforce’s engineering team set out to predict SLA breaches and major incidents in IT service management without customers needing data scientists, and without any real customer incident history to learn from at the start. They built three Predictive Model Templates: SLA Breach Prediction, Major Incident Prediction, and Change Risk Score. Scores and leading predictors are shown on the incident record through Data 360.

Synthetic data came from product manager samples, expanded by varying features and generated with open-source LLMs within product guardrails. The team noted that the simulated Customer Zero data was insufficient on its own, so grounding in realistic scenarios mattered more than volume.

Because SLA breaches are rare, aggregate accuracy can mislead; a naive model could look 95% accurate and still be useless. Instead, the team held all incident features fixed and varied one factor at a time, such as owners with a higher or lower historical milestone miss rate, checking that the score moved in the expected direction. They also checked whether the top three predictors matched what an experienced service manager would flag. The article stresses that these results validate tested scenarios, not production accuracy.

The template ships the training contract rather than fixed weights: DMO API names, transformation logic and model structure. Each customer’s history determines the learned parameters. Incidents, milestones and related records sync into DMOs, a daily transform labels milestone violations as a 0/1 target, and Einstein on Data 360 trains an XGBoost binary classifier. A scoring transform writes predictions to a score DMO, displayed on the AI Accelerator card.

Two constraints remain. Scoring runs as a scheduled batch about once an hour rather than in real time, chosen for scalability with large customers. Training requires roughly 400 completed incidents, and prediction quality depends on the customer’s history. The templates reached general availability in February.

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

Worth reading?

Recommended

Exposing HXL widgets to Slackbot through a custom MCP server (opens in a new tab)

You will learn what a custom MCP server needs before Slackbot can render HXL widgets, how to connect Slack through the Salesforce Org Connection, and how to set tool permissions and descriptions so the right tool is chosen.

Why read this

You will also see how to troubleshoot a missing card.

  1. Check the MCP server definition
  2. Map users by Federation ID
  3. Request and approve the org connection
  4. Add the MCP server in Slack admin
  5. Turn on the server and set tool permissions
Steps to make an HXL widget appear in Slackbot, in the order the article gives them

The article explains how to make an existing HXL widget appear in Slackbot. If a widget already renders in Claude or ChatGPT, it can render in Slackbot without changes to the widget, the Apex action or the Custom Lightning Types. The remaining work is configuration: deciding how Slack connects to the Salesforce MCP server, who can use it, and which tools Slackbot may run. The author uses the Pronto sample app to show a storefront card and a follow-up menu card.

Before connecting, the server must be active, every resource needs a description, each tool’s uiResource must match a resourceName, and each tool’s readOnly and destructive flags must be set. Slackbot treats unclassified tools as write tools, which adds confirmation prompts. The connection itself is made through the Salesforce Org Connection: users are mapped by Federation ID, the org is requested and approved from Slack and Setup, and the MCP server is added in Slack admin and confirmed by a Date added value.

Each user then turns on the server in Slackbot and approves tools, choosing Allow once, Always allow or Deny per tool. Two limits apply: up to five active servers per user, and a 60-second timeout per call, with stateless calls that rerun the Apex action, so calls should stay small. Overlapping tools on other servers or Slackbot’s own Salesforce search can cause a plain table instead of the card, so descriptions should be specific.

The troubleshooting section maps common symptoms, such as plain text, missing tools, or blank values, to causes and fixes. Testing with a debugging tool like MCP Inspector helps separate server definition problems from Slack problems.

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

Also told by InfallibleTechie (opens in a new tab)

Worth reading?

Salesforce in Microsoft Copilot and Teams, with zero-copy access to Fabric (opens in a new tab)

You will learn what the Salesforce and Microsoft integrations now offer: Salesforce context inside Copilot and Teams, and bidirectional zero-copy data sharing between Data 360 and Fabric.

Why read this

You will also see which parts are in beta, pilot or generally available.

Data Federation

  • Query Fabric OneLake data in Data 360
  • Source data stays in Fabric
  • Generally available

Data Sharing

  • Share curated Data 360 context to OneLake
  • Supports custom analytics and AI workloads
  • Public preview, beta
Data Federation lets Salesforce query Fabric data in place, while Data Sharing sends Data 360 context to OneLake

Salesforce and Microsoft have announced Copilotforce, a partnership that brings Salesforce customer context and sales workflows into Microsoft Copilot, adds real-time CRM collaboration in Microsoft Teams, and connects Salesforce Data 360 with Microsoft Fabric. Accenture is the design and implementation partner and is deploying the integrations in its own global sales organization.

Salesforce in Microsoft Copilot lets sellers ask natural-language questions and get grounded outputs, prepare for meetings, analyze opportunities and take supported CRM actions. Copilot’s Work IQ layer combines Salesforce data with Teams meetings, Outlook emails and shared documents on SharePoint and OneDrive. The article names three daily workflows: meeting preparation, deal-health analysis and pipeline review with close plans in Word and PowerPoint.

The Sales Cloud in Teams app, which was shown at Dreamforce, is in pilot. It shows pipeline and quota progress, sends deal notifications, and lets sellers update supported opportunity details through adaptive cards, with changes saved back to Salesforce. Agentforce Coworker handles actions within Teams.

On the data side, Data Federation is generally available and lets joint customers query Microsoft Fabric OneLake data inside Data 360 without moving it. Data Sharing is in public preview and beta and lets organizations share curated Data 360 context into OneLake. Access follows existing Salesforce permissions and Sharing Rules, and supported writeback actions require explicit user confirmation and respect Validation Rules. The article stresses that pricing and availability depend on customer agreements.

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

Worth reading?

Recommended

Salesforce Koa, a reasoning model trained on CRM work, is in pilot (opens in a new tab)

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.

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

Worth reading?

AI Skills let Agentforce Coworker run repeatable team tasks (opens in a new tab)

You will learn what AI Skills in Agentforce Coworker are, how they differ from Prompt Builder templates, and how sharing and permissions are meant to control them.

Why read this

The author notes that admin-level maintenance guidance is still missing.

AI Skills are reusable sets of instructions that tell Agentforce Coworker how to complete a repeatable task. The author compares them to skills in Claude: the task is defined once, and anyone with access can run it the same way each time. Salesforce says Coworker is the first Agentforce agent to include them. They were announced in pilot in September, with general availability planned for October, as part of a wider Coworker expansion covering Microsoft Teams, mobile and desktop apps, and an MCP server.

The article separates AI Skills from Prompt Builder. A Prompt Template gives a repeatable way to prompt an LLM for text output, such as a sales email or record summary. A skill describes a whole task so an agent can work through each step and take action, which the author says makes skills the more powerful of the two. Salesforce’s examples include account research, meeting prep, case classification, flagging renewal risk and case summaries, all work people repeat and often do slightly differently each time.

On governance, skills are private until the creator shares them, and sharing is controlled by the creator. A skill runs as the person using it, and Coworker respects existing permissions, so users should only see records and objects they already have access to. Coworker also pauses for approval before it creates or updates a record. The author argues this is powerful enough that admins need clearer guidance on maintaining skills across a team, and promises a deeper walkthrough later.

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

Worth reading?

AI Skills in Agentforce Coworker are now generally available (opens in a new tab)

You will learn what an AI Skill is, how users build, share and run one in Coworker, and how it differs from a Prompt Builder Prompt Template.

Why read this

You will also see how permissions and approval gates apply when a skill runs.

Prompt Template

  • Reusable prompt for an LLM
  • Produces text output
  • Example: a record summary

AI Skill

  • Describes an entire repeatable task
  • Agent works through each step
  • Can take action on records
A Prompt Template produces text, while a skill runs a whole task

AI Skills in Agentforce Coworker are now generally available. A skill is a reusable set of plain-language instructions that tells an agent how to complete a repeatable task. Unlike a Prompt Template, which produces text output such as an email or a record summary, a skill describes an entire task that the agent works through step by step and can act on.

Users build a skill by chatting with Coworker. They name it, say when to use it and list its steps, then refine the steps in Coworker or in Skill Builder. Skills are private by default and are shared with colleagues once they work. A skill is run by typing a forward slash, using the skills icon, or simply asking, and Coworker can select the matching skill from the user’s intent.

Skills respect the org’s existing controls. A skill runs as the invoking user with their row-level and object-level permissions, and Coworker asks for approval before creating or updating a record. The article suggests example uses such as account research, call prep, competitive battle cards, case summaries and campaign reporting.

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

Worth reading?

EGI-Bench scores AI agents across six enterprise skill dimensions (opens in a new tab)

You will learn how EGI-Bench groups eight benchmarks into six enterprise skill dimensions and a weighted global score, and what its tests found about choosing among 14 LLMs.

Why read this

You will also see how to run it in deep or quick mode and adjust the weights to your use case.

Deep mode

  • Runs the benchmarks in full
  • Gives a comprehensive evaluation

Quick mode

  • Subsamples each benchmark
  • Gives a faster directional signal
EGI-Bench's two run modes trade completeness for speed

Salesforce’s AI research team has built EGI-Bench, a framework for judging whether the LLMs behind enterprise agents are ready for production. The authors argue that many benchmarks test narrow skills, so an agent can pass evaluation and still fail on real enterprise work. EGI-Bench combines eight independently developed benchmarks, spanning more than 20 subdomains and 1,500 test tasks.

The framework scores six dimensions: task outcomes, tool actioning, planning, grounding, safety and engineering. Sub-metrics from the eight benchmarks are mapped onto these dimensions and normalised so they can be combined. The six subscores are then weighted into a single global EGI score, with default weights that users can change to suit their priorities.

To keep runs practical, EGI-Bench offers a deep mode that runs the full benchmarks and a quick mode that subsamples each one for a faster directional signal. A weak result in quick mode can be investigated more deeply rather than triggering every test at once.

The team tested 14 LLMs and reports three findings. No single model led on all six dimensions, so model choice should follow the work the agent does. Multi-step planning scored low across the models. Lower-cost models, including Haiku 4.5, GPT-5 mini and Gemini 2.5 Flash, performed competitively. EGI-Bench is available on GitHub, with a technical report for further detail.

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

Worth reading?

Must-read

How HXL widgets reach the screen in Agentforce and MCP clients (opens in a new tab)

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.

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

Worth reading?

Recommended

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

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

Why read this

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

Headless Toolkit

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

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

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

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

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

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

Worth reading?

Recommended

Builder Central lets admins build and edit in a virtual layer before touching the sandbox (opens in a new tab)

You will learn how Builder Central keeps proposed metadata changes out of your sandbox until you approve them, how it edits existing flows and apps, and what its new project-plan review step does.

Why read this

The piece is a podcast transcript, so the specifics are mostly the speakers' claims and a demo.

  1. Describe the idea in Builder Central
  2. Review the project plan before building
  3. Explore changes in the virtual environment
  4. Publish to the sandbox on your approval
How a Builder Central change reaches the sandbox, as described in the episode

Builder Central, now in beta, is a Salesforce tool that lets admins go from a description of an idea to a working solution on the platform without writing code. The podcast hosts describe it as the result of about two and a half years of internal work, built on the team’s headless and MCP efforts, and aimed at low-code builders. Early customers reported that tasks which took seven to ten days for several people now take one person two to three hours.

The central design point is that Builder Central works in a virtual environment rather than changing sandbox metadata while you build. Changes stay out of the org until you explicitly publish the project to the sandbox with a button or by asking the agent to do it. Visualizers show flows and other output as they would look in the org before anything is deployed, and the speakers say the team keeps adding them.

The tool also covers the maintenance work that makes up most of an admin’s job. Because it can read all the metadata in an org, it can refactor or test existing flows, and the hosts say it generated flow tests that a product manager judged to be good. A feature due around TDX will let users pull an existing app into a project and restyle it with a brand kit. A new step, rolling out that week, has the agent build a project plan for the user to review and approve before it starts building, and inline editing lets users select a single component to change.

The episode is promotional in tone and mostly anecdotal, so treat the productivity figures and comparisons with Claude Code as the speakers’ own account. The practical takeaway is the publish-on-approval workflow and the plan review step, which are the parts most relevant to governance and sandbox risk.

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

Worth reading?

Keep approval policy in data and deterministic code, not in an agent's prompt (opens in a new tab)

You will see why an AI agent should not decide business rules like discount approval, and how to structure it with an explicit approval matrix, gated tools, and a needs_human outcome.

Why read this

The code is generic Python rather than Salesforce-specific.

  1. Agent calls request_discount
  2. Look up approver in matrix
  3. Approver found: pending approval
  4. None available: needs human
How a discount request is routed through the approval gate

The article argues that an AI agent is essentially an LLM in a loop, and that the difficulty in a company lies in the policy questions nobody has answered, such as who may approve a discount above a rep’s limit when the usual approver is unavailable. An agent should not invent such a policy, because any answer it gives looks like a decision but is only a guess.

The proposed design moves policy into data the business owns, such as a table or Custom Metadata listing discount thresholds, the role allowed to approve, and a backup role. A deterministic function looks up the approver and returns nothing when nobody is available, so the case escalates instead of being guessed. Tools that change money, prices or contracts never apply changes directly; they return a pending proposal that a gate handles.

The loop itself stays simple, but it needs a step limit, an allowlist of registered tools, and a first-class needs_human result that explains why the agent stopped. Read and write tools should be treated differently. The author also notes that decisions expressible as simple rules belong in Flow, Apex or plain code, and that agents suit cases needing interpretation of free text or messy context.

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

Worth reading?

Agentforce Coworker is switched on in some orgs, so check it before users ask (opens in a new tab)

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.

  1. Check whether Coworker is already on
  2. Review sharing and fix over-broad access
  3. Build a few focused agents
  4. 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.

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

Worth reading?

Salesforce Catalog gives AI assistants a live index of your org's metadata (opens in a new tab)

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.

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

Worth reading?

Koa Decisions, a small model for fast routing Decisions in Agentforce (opens in a new tab)

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.

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

Worth reading?

Must-read

Building and testing agents in the new Agentforce Builder (opens in a new tab)

You will learn how to create an agent from a natural-language description, switch between Canvas and Agent Script views, and test with Simulate and Live Test before committing and activating a version.

Why read this

It is a practical walkthrough of the Builder's main workflow.

  1. Describe the agent in natural language
  2. Refine in Canvas or Script view
  3. Test in Preview
  4. Commit Version
  5. Activate the version
The Builder workflow from creating an agent to going live

The new Agentforce Builder, found under Agentforce Studio, is presented as a way to make agent behavior more predictable by combining an upgraded reasoning engine, Agent Script that mixes natural language with programmatic logic, and built-in AI assistance. An agent can be started by describing its role and tasks in natural language, after which Agentforce generates an initial configuration that can be refined through chat or configured manually.

The Builder is organized into an Explorer for navigating settings, subagents, actions, variables and connections, a Canvas for editing configuration in a low-code block view, a Preview panel for testing, and an Agent Optimizer for natural-language changes. Canvas and Script views stay in sync, so changes made in one are written into Agent Script in the other. Typing a slash adds inline logic such as if/else conditionals, and typing an at-sign opens a resource picker for subagents, actions and variables.

Preview offers Simulate, which skips permission checks and does not run actions or touch data, and Live Test, which runs actions and changes data in the org. Both show reasoning explanations, traces, variable values and timing per step. Finally, a version is committed as a locked snapshot and activated; only one version can be live at a time, and activating a new one turns the previous one off.

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

Worth reading?

Recommended

Fixing the field-access error in Agentforce Answer Questions with Knowledge (opens in a new tab)

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.

  1. Assign Data Cloud User Permission Set
  2. Grant Read on Knowledge and mapped fields
  3. Enable Allow View Knowledge
  4. Verify data space access
  5. 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.

Read the original at InfallibleTechie (opens in a new tab)

Worth reading?

Agentforce Coworker adds Teams, mobile and desktop access and a $50 per-user price (opens in a new tab)

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.

  1. Employee delegates a job
  2. Coworker plans the steps
  3. Agents and flows run
  4. 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.

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

Also told by dev.to (opens in a new tab)

Worth reading?

Koa Decisions brings fast single-step decision models to Salesforce builders (opens in a new tab)

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.

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

Worth reading?

Tableau Data Apps bring governed agentic analytics to vibe-coded apps (opens in a new tab)

You will learn what a Tableau Data App is, where it can be built and published, and how it inherits Tableau's security, semantics and refresh model.

Why read this

The piece is a product overview in beta, so the detail on setup is thin.

  1. Connect your agent via MCP
  2. Prompt your intent
  3. Preview, iterate and verify
  4. Publish and share
The four steps to get a Tableau Data App from prompt to shared link

Tableau Data Apps, now in beta, are custom interactive analytical web apps hosted and powered by the Tableau platform. They separate the visual front end from the query engine, so builders can use AI agents to produce apps quickly while the apps still draw on Tableau’s semantics, connectivity and governance. The article argues that visualization was never the hard part, and that without an analytics platform agent-built apps risk guessing at business definitions, running slow and costly query loops, and leaking credentials or data.

Apps can be built in Tableau Studio or with any third-party agent connected through the Tableau MCP server or Tableau Next MCP server. Apps built in Tableau Studio publish to Tableau Cloud or Server, while apps built with third-party agents can publish to Tableau Cloud, Server or Tableau Next. Inside Tableau Cloud and Server, apps sit in workbooks and query Published or Embedded Data Sources, and in Tableau Next they sit in workspaces and use Tableau Semantics.

Data freshness comes from live connections or scheduled extract refreshes, and federated queries let apps reach heterogeneous sources without copying data. Database credentials stay in Tableau, and object-level and row-level security apply to every user. The getting-started steps are to connect an agent, prompt the intent, preview and verify the logic, then publish and share.

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

Worth reading?

Recommended

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

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

Why read this

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

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

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

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

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

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

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

Worth reading?

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

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

Why read this

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

Headless Toolkit

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

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

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

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

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

Worth reading?

Recommended

Testing product knowledge grounding for Agentforce with Data 360 (opens in a new tab)

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.

  1. Hypothesize how the change affects answers
  2. Build the recipe in Data 360
  3. Evaluate with quantitative and qualitative tests
  4. 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.

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

Worth reading?

Skills admins need to build with AIforce's MCPs, Skills and Plugins (opens in a new tab)

You will learn how MCPs, Skills and Plugins fit together in the AIforce extensibility stack and which new admin skills to pick up first.

Why read this

It gives a roadmap and the training trails to follow.

  1. User triggers a Plugin
  2. Skill fires
  3. MCP executes
  4. Output returns to user
How the AIforce building blocks work together when a user acts

The post introduces AIforce as a new layer of the AI extensibility stack and explains three building blocks. MCP, the Model Context Protocol, is a standard bridge between an AI interface and live systems, data and APIs, so admins can expose flows, APIs and Apex without writing custom code for each system. Skills define the exact steps, rules and formatting an AI needs to complete a task consistently, and Plugins package MCP connectors, Skills and interfaces into a single installable product. It describes a flow in which a user triggers a Plugin, a Skill fires, an MCP executes and the output returns to the user.

The author lists the new admin skills to develop: MCP management, including centralised org-wide connections and Agentic Identity; building deterministic agent logic with Super Agents and Subagents; lifecycle management of Plugins mapped to user roles; and using Agentforce Coworker, Agent Script, Builder Central and Agentforce Vibes for AI-assisted building. The roadmap moves from AI Trust, Security and Governance trails through hands-on work with Agentforce Studio to advanced building and packaging, then ongoing change management.

The article is largely an overview with links to trails, workshops and resources rather than technical implementation detail, so practitioners will get orientation more than hands-on specifics.

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

Worth reading?

Agentforce Memory policy update roughly doubles recall of stated and changing facts (opens in a new tab)

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.

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

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

Worth reading?

Salesforce unveils AIforce apps linking platform data to Claude and Slack (opens in a new tab)

You will learn what the three AIforce applications are, what each does with Salesforce data, and what the Claude Code plug-in adds for developers.

Why read this

The piece is a brief overview without implementation detail.

AIforce initial release

  • Claudeforce
  • Slackforce
  • Agentforce Coworker
The initial AIforce release is made up of three applications

Salesforce announced AIforce at Dreamforce, a set of applications that connect platform data and workflows to Claude and Slack. The initial release has three parts: Claudeforce, Slackforce and Agentforce Coworker. Claudeforce comes out of an expanded partnership with Anthropic and ships with 37 pre-installed sales capabilities, from prospecting to opportunity management, plus a Claude Code development add-on with more than 40 further tools. Deloitte, GitLab and Legora piloted it, and it is now in beta for all customers.

Slackforce brings Salesforce data into Slack conversations, letting teams combine information from different sources, apply filters and take actions through interactive surfaces. The upgraded Slackbot assistant and Slack CRM feature can update files and create records from simple text commands.

Agentforce Coworker works inside Salesforce’s internal Lightning environment as a digital assistant that uses customer history and activity. According to the company, it needs no data migration or new permission settings, and it recorded 100,000 activations in its first 35 days.

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

Worth reading?

Recommended

Poor agent context inflates token use and Flex Credit spend (opens in a new tab)

You will learn how weak business context makes Salesforce agents burn far more tokens, and which low-cost habits (documenting objects, defining terms, cleaning records, using Flow where no reasoning is needed) reduce that cost before Headless Platform Interaction metering starts.

  • 43,000: Tokens used without the harness, with a wrong answer
  • 7,000: Tokens used with the configured harness
The same question used far fewer tokens once the agent had proper business context

A Dreamforce demo followed a sales rep asking an agent which customers to focus on to close a Q3 gap. Without a harness, the agent used 43,000 tokens and gave a wrong answer: it recommended a frozen customer, missed a renewal already in the pipeline, and misread fiscal Q3. With a properly configured harness that pulled live pipeline data, used a semantic layer to define Q3, and drew on memories of past customer interactions, the same question took 7,000 tokens and produced a sound answer.

The article argues that Flex Credit burn comes largely from the context an agent must work out for itself. Outcome-based pricing and the planned charge for Headless Platform Interactions make this matter, since the meter runs whether or not the answer is good. No multiplier has been published yet, and Salesforce has promised 30 days’ notice before metering starts. Context packs let a harness supply only the subset of information an agent needs, so the aim is the right context rather than the most context.

The author suggests practical steps for now: fully document the one or two objects agents will rely on most, write down ambiguous definitions such as fiscal quarters, clear stale and duplicate records, use a plain Flow where a deterministic answer is enough, and record a consumption baseline before metering gets more complicated.

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

Worth reading?

Recommended

Salesforce Agent Fabric adds cross-platform evals, due January 2027 (opens in a new tab)

You will learn what Salesforce's planned Agent Evals and API Evals do, how the availability timeline looks, and how they compare with evaluation tools already on the market.

Why read this

You will also see where the promised features are still only roadmap.

  1. Define what the agent should and should not do
  2. Generate a test set from requirements
  3. Grade results with an LLM judge and data checks
  4. Quarantine the agent if quality thresholds fail
Agent Evals workflow as described for the January 2027 general availability

Vernon Keenan, writing for SalesforceDevops.net, reviews Salesforce’s Agent Fabric update, which adds Agent Evals and API Evals to its agent control plane. Agent Evals is pitched as working across any platform: it generates tests before deployment, scores production agents against quality thresholds, and can trigger a kill switch. API Evals generates functional and performance tests from API specifications so breaking changes are caught early. Salesforce’s earlier Agentforce Testing Center, generally available in February 2025, covered only Agentforce agents.

The availability timeline matters. Agent Evals and API Evals target beta in November 2026 and general availability in January 2027, and the triggered kill switch also targets January 2027. What is generally available today is the defensive layer: a manual kill switch, a FinOps dashboard, Model Wallet budget limits, cost optimization policies, and federated gateway policies. Salesforce says the policies cut token usage by up to 75% in test scenarios, which Keenan treats as a best case. Cross-platform LLM and MCP server evals are still labeled “coming soon,” and Salesforce has not confirmed live-traffic scoring. Keenan argues that enterprises are buying the control plane mainly to manage sprawl, while orchestration features wait on customers’ workflows.

Keenan compares the offering with tools already on the market, including Arize Phoenix, LangSmith, Langfuse and Braintrust, which offer evals and tracing, some with online scoring. He also cites AWS AgentCore Evaluations, Google Cloud agent evaluation, IBM watsonx Orchestrate and ServiceNow AI Control Tower, which has a kill switch that revokes credentials. Developer tools instrument the agent’s own build, while Agent Fabric governs agents its customers did not build and can pause them. A key unanswered question is whether Agent Evals will show step-level traces for third-party agents, since a failing score without a trace explains little.

In his closing section, Keenan urges Salesforce to make evals the centerpiece. His recommendations include shipping a versioned test suite with each context pack, making eval libraries exportable in open formats, grading live traffic with linked traces, and bringing Testing Center customers into Agent Evals. He also asks Salesforce to publish a reproducible benchmark before the January general availability, comparing a frontier model alone, the same model with equivalent data access, and the model using the Enterprise AI Harness.

Read the original at SalesforceDevOps.net (opens in a new tab)

Worth reading?

Must-read

Building a shared semantic model for conversational analytics with Data 360 and Tableau semantics (opens in a new tab)

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.

  1. Ingest CRM data into DLOs
  2. Define metrics in OSI YAML
  3. Convert to SDM JSON
  4. Create and validate the model
  5. 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.

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

Worth reading?

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

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

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

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

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

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

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

Worth reading?

Recommended

Agent Fabric adds evals, kill switch and hard spending limits for agents (opens in a new tab)

You will learn what Agent Evals, API Evals and the cost controls in Agent Fabric do, and how automated quarantine and budget caps are meant to work once an agent is in production.

Why read this

The article also notes that these checks are only as good as the tests and thresholds behind them.

  1. Scheduled tests run on the agent
  2. Quality issue flagged by Agent Evals
  3. Approval requested to quarantine agent
  4. Instructions revised and evaluation rerun
How Agent Evals responds when an agent's quality drops after a model change

Salesforce is introducing Agent Evals, API Evals and advanced cost controls for Agent Fabric, its control plane for AI agents. The company says that problems in agents, such as changes in models, APIs or costs, can surface silently, and that resolving them today means finding the owner and getting approval to restrict an agent while it keeps producing bad results and spending tokens.

Agent Evals generates tests before deployment and then evaluates agents, LLMs and MCP servers in production. When results fall below the evaluation standards, predefined interventions such as the Agent Kill Switch are triggered, subject to approval where a team’s policy requires it. API Evals creates functional and performance tests from API specifications so that breaking changes are caught before production. The FinOps Dashboard and Model Wallet show AI spending and enforce hard limits that can stop requests before a budget is exceeded, and Cost Optimization Policies are said to cut token usage by up to 75 percent in test scenarios through semantic caching, payload compression and response trimming.

The article gives a retailer example in which a switch to a cheaper model leads scheduled Agent Evals runs to find inaccurate delayed-order answers, after which the agent is quarantined with approval, its instructions are revised, and the evaluation is rerun before it returns to production. The author closes by noting that the Agent Kill Switch is the main takeaway, and that the value of these evaluations depends on the tests and thresholds behind them.

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

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

Worth reading?

Recommended

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

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

Why read this

The exact multiplier is still unannounced.

Traditional integrations

  • Existing pricing kept
  • Existing security kept

Registered agents

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

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

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

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

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

Worth reading?

Connecting Data Cloud to Agentforce Studio to build an agentic RAG pipeline (opens in a new tab)

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.

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

Worth reading?

Must-read

Route real phone calls to your Agentforce Voice agent using Salesforce CLI and Omni-Channel flows (opens in a new tab)

You will learn how to configure an Agentforce Service Agent user, request a phone number, and build a one-element Omni-Channel routing flow to connect callers to your voice enabled script.

Why read this

You will also know how to verify call routing and inspect post call records using the Salesforce CLI.

  1. Verify entitlements and licenses
  2. Create an Agentforce Service Agent user
  3. Build an Omni-Channel routing flow
  4. Activate the flow and PSTN Voice channel
  5. Test the call and query records
This diagram shows the five-step process for routing real phone calls to an Agentforce Voice agent

The article explains that routing live calls requires an active Agentforce Voice agent, a dedicated Einstein Agent User license, and available inbound voice credits. Developers must verify entitlements and create a service agent user through the Salesforce CLI before configuring any routing logic.

A call reaches the agent through three linked components: a purchased phone number, a PSTN Voice channel, and an Omni-Channel flow. The flow requires a single input variable named recordId and one Route Work element that directs the call to the activated service agent, with a voice queue as a fallback.

After activating the flow and channel, administrators can test the connection by dialing the assigned number. Since live sessions do not generate transcripts, the author demonstrates how to query VoiceCall and AgentWork records via SOQL to confirm call duration, vendor type, and successful routing.

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

Worth reading?

Salesforce discusses partner concerns over new AI agent billing model (opens in a new tab)

Readers will learn how Salesforce plans to charge Flex Credits for external AI agent interactions via MCP and APIs, and what partners are urging the company to adjust regarding predictability and friction.

Salesforce has introduced a pricing model requiring external artificial intelligence agents to register on the platform and consume Flex Credits for every successful call made through the Model Context Protocol or direct application programming interfaces. The initiative tracks each interaction as a Headless Platform Interaction, shifting costs away from traditional seat licensing toward usage-based billing for agentic traffic.

The announcement triggered significant pushback from implementation partners and independent architects who warned that per-action charges would create financial friction and discourage developers from building around the platform. Critics noted that customers already face heavy seat costs and questioned whether the market would accept paying for every individual request made by automated systems.

In response to the community reaction, Salesforce leadership initiated direct conversations with key ecosystem stakeholders to address these concerns. Participants emphasized the need for transparent pricing structures, additional platform value to justify the fees, and mechanisms that allow partners and administrators to continue leveraging artificial intelligence tools without unexpected production expenses.

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

Worth reading?

Recommended

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

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

Why read this

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

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

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

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

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

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

Worth reading?

Recommended

Six checks to vet agents and MCP tools before installing from AgentExchange (opens in a new tab)

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.

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

Worth reading?

Security researchers identify unauthenticated prompt injection paths in Agentforce (opens in a new tab)

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.

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

Worth reading?

Must-read

Connecting ChatGPT and Codex to Salesforce through plugins and the DX MCP (opens in a new tab)

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.

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

Worth reading?

Recommended

Securing Agentforce against prompt injection and data exfiltration (opens in a new tab)

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.

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

Worth reading?

A practical workflow for cleaning Salesforce data before implementing AI (opens in a new tab)

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.

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

Worth reading?

Recommended

Using the JSON Path function in AgentScript to extract and filter data (opens in a new tab)

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.

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

Worth reading?

Must-read

How Agentforce Coworker delegates requests to Employee Agents (opens in a new tab)

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.

  1. User submits a request to Agentforce Coworker
  2. Coworker cannot complete the request itself
  3. Reads accessible agent and subagent descriptions
  4. Compares request against agent capabilities
  5. 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.

Read the original at InfallibleTechie (opens in a new tab)

Worth reading?

Recommended

Agentforce Service offerings explained for configuration and rollout planning (opens in a new tab)

Readers will learn how to configure and deploy Agentforce Service agents, understand the prerequisites for Omni-Channel routing and Knowledge grounding, and see which legacy channels are being retired.

Why read this

The piece also outlines practical rollout strategies to avoid common implementation pitfalls.

The piece is a guide to Agentforce Service, Salesforce’s AI customer service platform, which was renamed from Service Cloud in October 2025. It covers seven offerings: AI agents, case management, omnichannel contact center, an AI knowledge base, field service, analytics and integrations. For each, it explains what the offering does, what it depends on and where teams tend to run into trouble. The AI agents come in two forms. Help Agent is prepackaged and set up from one screen, and it is grounded on Salesforce Knowledge, uploaded files or a website sync. It needs Enterprise or Unlimited Edition with Agentforce enabled. Service Agent is configurable, with topics, instructions and actions defined by the team, and suits work that touches the company’s own systems, such as order lookups or appointment changes. Agentic features such as Agentic Milestones, MCP support and multi-agent setups are also described. Omni-Channel routing depends on Enhanced Omni-Channel, which the article calls the foundation for Agentforce Service and a requirement for Agentforce Voice and Contact Center.

On the contact center and channels, the article notes that Salesforce is retiring Standard Facebook Messenger and Standard SMS channels in mid-2026, so teams still on them should move to Enhanced channels. It also points to the knowledge base as a dependency: AI answers are only as good as the Knowledge articles behind them, so the author recommends knowledge-centered service habits. Case management, field service work orders, analytics (with metrics such as autonomous resolution rate, escalation rate and CSAT on AI-handled cases) and MuleSoft-based integrations with ERP and telephony systems are each summarized with their key requirements. Pricing mixes per-user licenses, Flex Credits and a per-resolution charge for Help Agent, and the article advises confirming current India pricing with Salesforce.

The rollout advice is the practical core. The author suggests auditing data and the knowledge base first, setting up Enhanced Omni-Channel, launching one AI agent on a single high-volume, low-risk queue, measuring results for a month and then expanding, with budget kept for ongoing tuning after go-live. The article is written by Cloud Odyssey, a Salesforce partner, and it promotes its own services, so its vendor-supplied performance figures (such as 72% of routine inquiries offloaded and 70% resolution on Salesforce’s own help portal) are presented as numbers to test rather than guaranteed results.

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

Worth reading?

Salesforce introduces Deep Insights and Moirai for real-time operational intelligence (opens in a new tab)

Readers will learn about two new Salesforce AI capabilities designed to analyze live business data and predict trends without manual dashboard monitoring.

Why read this

The piece outlines how these tools reason over structured data and forecast demand using built-in business context.

The article frames enterprise data challenges around the historical analogy of radar, noting that businesses currently lack a layer to make massive real-time data streams legible before action windows close. It introduces operational intelligence as the solution, moving beyond static dashboards toward continuous AI reasoning over live information.

Two specific models power this approach. Deep Insights processes structured business data to trace issues to their root causes and recommend subsequent steps. Moirai handles time-series forecasting by predicting demand and detecting anomalies while automatically incorporating known business variables such as seasonal shifts or renewal waves.

Salesforce is already deploying these capabilities internally. Engineering 360 uses Deep Insights to correlate patterns across ninety billion records, while the Contact Center division applies Moirai to optimize staffing and demand planning. The company plans to extend these reasoning layers across sales pipeline management, marketing performance tracking, and supply chain operations.

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

Worth reading?

Salesforce announces Agentic Identity and flex credit adjustments for Model Context Protocol servers (opens in a new tab)

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.

Read the original at Nebula Consulting (opens in a new tab)

Worth reading?

Must-read

Using Prompt Builder and generative AI to manage requirements and prevent scope creep (opens in a new tab)

Readers will learn how to structure discovery notes, audit meeting transcripts, and build low-fidelity prototypes using Prompt Builder to catch vague requirements early.

Why read this

The piece also outlines practical safeguards against AI hallucinations when reviewing change requests.

  1. Extract requirements from raw discovery notes
  2. Flag scope deviations in meeting transcripts
  3. Build quick prototypes to catch edge cases
  4. Ground change requests with Prompt Builder
  5. Keep final approval with human project managers
A five-step AI workflow to structure requirements, audit meetings, prototype solutions, and maintain human oversight

Scope creep often stems from unclear requirements and unapproved changes during Salesforce implementations. The article proposes using generative artificial intelligence as a systematic reviewer to compare stakeholder requests against signed-off project charters before development begins.

Practitioners can feed raw discovery notes into large language models to extract structured acceptance criteria, dependencies, and open questions. Meeting transcripts should be processed to flag deviations from the approved scope, creating a verifiable audit trail without relying on human memory.

Interactive prototypes generated quickly with AI help align stakeholder expectations with technical deliverables, exposing edge cases that text documents miss. For teams already tracking requirements inside the platform, Prompt Builder can ground automated prompts to evaluate change requests against existing records.

Despite these advantages, the author warns that AI systems frequently struggle with reproducibility and hallucination. The guidance emphasizes keeping final approval authority with human project managers while using AI strictly as an early warning and documentation assistant.

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

Worth reading?

Must-read

Preparing your org for the Claudeforce partnership and new billing model (opens in a new tab)

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.

  1. Audit Permission Sets and profiles
  2. Clean the fields the skills read
  3. Keep approvals on
  4. Pilot in a sandbox
  5. 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.

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

Worth reading?

Must-read

Configuring permissions and security guardrails for Agentforce and Prompt Builder (opens in a new tab)

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.

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

Worth reading?

Recommended

Building a custom Apex tool for Lead conversion with Salesforce Model Context Protocol (opens in a new tab)

You will learn how to configure a Salesforce Model Context Protocol server and write an Invocable Apex class to handle Lead conversion through AI agents.

Why read this

The piece clarifies why generic record mutation tools cannot replace the native conversion process.

Introduces Salesforce Headless 360 and the Model Context Protocol as methods for AI agents to interact with orgs. Explains that basic access is free but may consume Flex Credits.

Walks through creating a custom MCP server in Setup and notes that default tools do not support Lead conversion. Details the architectural reason why generic SObject mutation tools fail for this task, citing atomic execution, field mapping, deduplication, and related record reparenting.

Outlines the requirement to build an Invocable Apex class using Database.convertLead(). Describes the necessary annotations and access modifiers needed to expose the method to the MCP framework.

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

Worth reading?