The independent daily for Salesforce admins, developers and architects

Curated by Abhinav (opens in a new tab)

Recommended

How an MCP tool cut triage of 600 test failures to about 90 minutes (opens in a new tab)

You will learn how Salesforce engineers split deterministic code from AI reasoning in an MCP workflow that clusters and reassigns test failures, and which guardrails prevented duplicate work items and misrouting.

Why read this

The reasoning is useful even if you never touch the GUS internals.

  1. Retrieve failures
  2. Gather context from stack traces
  3. Detect patterns or apply categories
  4. Reassign individually, in bulk or by team
The workflow runs through four stages, from retrieval to reassignment

Salesforce’s engineering team faced over 600 test failures triggered by the retirement of the SOAP API login mechanism. Expected failures and genuine regressions could produce similar exceptions and span several scrum teams, so a wrong classification could hide a real defect or send engineers chasing the wrong problem for days. The existing process required manual stack trace reading and reassignment through an interface limited to 50 failures at a time, and it could create duplicate work items or misroute failures.

The team built AI-Assisted Test Failure Buddy as a Python and FastMCP process exposing eight tools to Claude Code or Cursor, connected to the APIs behind GUS, Salesforce’s internal work item system. The design separates an interface layer of typed MCP tools, a core logic layer that controls API calls, identifiers, parsing, validation, batching, clustering and reassignment, and a support layer for authentication and tokens. The workflow runs in four stages: retrieve failures, gather context from stack traces, detect patterns or apply categories, and reassign failures individually, in bulk or by team.

Grouping was the hardest part. Stack traces offer no stable key for root cause, and the same exception type could mean an expected SOAP login failure in one context and an unrelated bug in another. The team combined deterministic processing, such as regular-expression matching and a preset recognizing strings like INSUFFICIENT_ACCESS, with AI reasoning reserved for novel traces, unmatched clusters and ambiguous ownership. To avoid duplicates, the tool assigns related failures to one existing work item and uses explicit failure IDs in place of the broader interface action that had caused misrouting.

The estimated two or three days of manual triage for one 600-failure work item fell to roughly one to one and a half hours for a single engineer. The tool has since been used by three or four teams, though it has no adoption telemetry yet. The article also notes that Claude Code helped build the tool, starting from a markdown design document with human review throughout.

Read the original at Salesforce Engineering (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

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?

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?

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?

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?

Recommended

Salesforce Headless 360 exposes the platform to agents through APIs and MCP (opens in a new tab)

You will learn what Salesforce Headless 360 offers through its three access paths, why governance has to move from the UI to the schema, and how to start a controlled pilot with a Hosted MCP Server.

  1. Pick one workflow
  2. Audit the schema
  3. Connect a sandbox client
  4. Define agent identity and limits
  5. Test, trace and measure
A five-step plan for a first Headless 360 pilot

Salesforce Headless 360 is an architecture that exposes Salesforce capabilities through APIs, Model Context Protocol (MCP) tools and CLI commands, so AI agents, apps and developer tools can use the platform without a browser. Announced at TDX 2026, it keeps the data, workflows and business logic built over 25 years, and the company now also calls the offering Headless Toolkit. Salesforce cites more than 60 MCP tools, 30 preconfigured coding skills, 4,000 APIs and 220 CLI commands, and states that Lightning and the browser remain available for human users.

The piece explains three access paths. APIs serve developers and integration platforms that read and write records. MCP tools let AI clients such as Claude, ChatGPT and Cursor discover and call capabilities at runtime, with no custom integration code written in advance. CLI commands support scaffolding, testing and deployment through DevOps pipelines. MCP tools are further split between coding agents, which read metadata, generate Apex and deploy, and business agents, which reach Salesforce from Slack or other chat clients. Hosted MCP Servers became generally available in April 2026, and the Headless 360 MCP Server followed in beta in July 2026. Every Hosted MCP call runs as the authenticated user through an External Client App with the mcp_api scope, and the article warns that pricing via Flex Credits may bill for usage, so teams should confirm terms with their account team.

For architects, the central change is that governance moves from the screen to the schema. An agent never sees a page layout, so Validation Rules, sharing models, Apex and approvals must carry the controls. The article proposes a four-layer view of experience, access, execution and data, and lists review questions about rule placement, least-privilege Permission Sets, human-only actions and approval points for high-risk actions. It also covers the Headless Experience Layer and Multi-Framework support for React, and notes that agent testing needs evaluation sets, session tracing and the Agentforce Testing Center. MuleSoft supplies governed access to systems outside Salesforce, while Data 360 supplies unified customer context.

The article suggests starting with one workflow, auditing the schema, connecting a sandbox Hosted MCP Server to one client, defining agent identity and limits, and then testing, tracing and measuring results against the manual process. It treats vendor customer stories as reference points only and advises a pilot to generate real evidence.

Read the original at Cloud Odyssey (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?

Must-read

Running Apex tests locally so AI coding agents can iterate on them (opens in a new tab)

You will learn why coding agents stall on Apex when every test run needs a Salesforce org, and how a local Apex runtime exposed through an MCP server gives an agent a fast write-run-fix loop.

Why read this

You will also see the boundary the article draws around deployment.

Against an org

  • Deploy class to an org
  • Wait, then start test run
  • Poll until finished
  • Minutes per cycle

Against a local runtime

  • Run tests on the machine
  • Read structured results
  • Fix and rerun
  • Seconds per cycle
Agent loop against a Salesforce org versus against a local Apex runtime

The article argues that AI coding agents stall on Salesforce Apex because Apex only runs inside a Salesforce org, so each test cycle means deploying, waiting, polling and parsing logs, which can take minutes and requires org credentials. Agents then either stop iterating and hand back untested code, or keep going at a high cost in time and tokens. The author’s published benchmark puts four open-source Apex suites, 837 tests in total, at about 1 minute 46 seconds to deploy and run in an org, against 2.4 seconds locally. The piece also notes that Nimbus was renamed renmy runtime in October 2026, with the same binary and the MCP server name nimbus kept.

The proposed fix is renmy runtime, a local Apex runtime that executes classes, triggers, SOQL, DML and Salesforce Flows against an embedded PostgreSQL, with no org, sandbox, Docker or JVM. The author says it enforces governor limits and mirrors platform behaviour such as Test.startTest and Test.stopTest, and that it is not a mock or a transpiler, though it does not achieve perfect parity. Its renmy mcp command runs as a stdio child process of the agent, so no port or credential is needed. The exposed tools include run_apex_tests, explain_failure, get_coverage, get_execution_trace, execute_anonymous and list_test_classes, which return structured results rather than logs to parse. Setup is a one-line install, a test run in the project, and registration with Claude Code, Cursor or GitHub Copilot.

A worked example shows an agent adding a discount rule to an invoice service: it lists existing tests, writes a method and test, runs the suite, uses the failure explanation to find a status filter bug, fixes it, and uses coverage to add a boundary test, all within seconds and without touching an org. The author also connects this to Salesforce Headless 360, where Apex hooks such as InvocableMethod and RestResource become tools for Agentforce or external agents, and says the runtime can test that underlying Apex offline.

The article draws a firm boundary around deployment. A green local run is necessary but not sufficient, because the org holds Permission Sets, managed packages, Validation Rules and other teams’ automation that a repository does not contain. The agent should not deploy on its own. renmy deploy runs local gates, then a real check-only validation in the org before deploying, while renmy release validate and renmy release deploy add a human approval step and an immutable receipt between the two. The Free tier covers unlimited local test runs, and the MCP server is a Pro feature that is free during the public beta.

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?

Must-read

Building interactive UI with the Headless Experience Layer for Agentforce and MCP clients (opens in a new tab)

You will learn how to structure declarative JSON widgets, bind them to Apex data using Custom Lightning Types, and configure Agentforce to render interactive cards instead of plain text.

  1. Write an Apex invocable method to return data
  2. Package the layout into a UiWidgetBundle
  3. Link output shape to widget via renderer config
  4. Update Agent Script to mark data displayable
  5. Test layouts in HXL Playground before deploy
Workflow for building and testing interactive widgets with HXL

The post introduces the Headless Experience Layer (HXL), part of Salesforce’s Headless Toolkit, which lets developers define an interactive widget once in declarative JSON and have it render natively in Agentforce and in any MCP client that supports MCP Apps. Instead of an agent replying with plain text, the same action can return a branded card that looks and behaves consistently across channels. Widgets are composed from reusable components rather than built as Lightning Web Components or React apps, and they only display what the underlying Apex action returns, so existing sharing and field-level security still apply. HXL rests on three concepts: components, which are surface-aware UI primitives; widgets, which combine components into a use case; and Custom Lightning Types (CLTs), which describe the shape of the data and whose renderer tells the platform which widget draws it and how fields map onto its attributes.

The authors illustrate the approach with a review card from Pronto, their fictional food-delivery sample app. The card is built from four pieces: a global Apex invocable action (GetCustomerReviewsAction) that returns review data; a widget whose files live in a UiWidgetBundle, namely a registration XML file, a JSON composition built from tile blocks with a forEach loop for list items, and an optional schema; a CLT that binds the action’s output to widget attributes using {!$attrs} and similar paths; and an agent output or MCP tool that marks the output as displayable. In Agentforce, the Agent Script sets is_displayable to True, and the model decides when to show the card, which in the authors’ testing usually happens on the first question of a fresh conversation. For MCP clients such as Claude and ChatGPT, two nested CLTs are needed because the tool output is wrapped in an envelope; only the outer type carries the renderer, and an MCP server entry publishes it as a UI resource that the tool references. The HXL Playground offers a browser-based way to preview layouts with sample data, though previews may differ from the live experience.

The post closes with getting started steps: enable Headless Experience Layer (Beta) under Feature Settings in Setup, use API version 67.0 or later, clone and install the Pronto app, and optionally use the open-source Salesforce Skills library to generate widgets, CLTs and MCP types with an AI agent. It also points to a hands-on workshop, and it presents HXL as a way to deliver consistent interactive UI across agent surfaces with less integration code.

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

Worth reading?

Recommended

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

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

Why read this

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

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

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

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

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

Worth reading?