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

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?

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?

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?

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?

Four rules for constraining an AI agent that deploys to Salesforce (opens in a new tab)

You will learn a design for letting an AI agent handle Salesforce deploys safely: a fixed action menu, approval gates, org-checked results and logged, capped runs.

Why read this

The reader comes away with a concrete set of guardrails to consider.

  1. Plan reviewed and approved
  2. Check-only validation in production
  3. Human clicks to deploy
  4. Org queried to verify results
The agent works through three human approval gates before production changes

The author argues that the slow part of a Salesforce deploy is usually assembling the package, choosing tests and target org, and interpreting failures, which are language tasks suited to a model. Deployment itself is not, so the agent is designed around four rules.

First, the model never touches an org. It receives no credentials, shell or sf CLI access, only a fixed menu of actions such as validate, deploy, run tests, query and retrieve. Code checks its parameters and performs the action with the sf CLI and git.

Second, humans approve at three points: the plan, which shows components, target org, tests and risk; a changed plan, when a retry alters components or scope; and production, where a check-only validation runs before a human deploys, including destructive changes. Sandbox steps run automatically while everything stays green. Third, success is verified by querying the org, not taken from the model, and the summary is written from that evidence table. Fourth, every run is logged, with a cost cap and a limit of three retries.

The model’s role is limited to turning a request into a reviewable plan and turning a failed deploy into a plain explanation, such as a test that does not set a new checkbox and so trips a new Validation Rule.

Read the original at dev.to (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

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?

Recommended

How Agentforce Health Monitoring detects silent failures and reduces alert latency (opens in a new tab)

You will learn how Agentforce Health Monitoring unifies fragmented telemetry to detect silent availability failures and reduce alert latency to under two minutes.

Why read this

The piece explains the current debugging workflow and outlines upcoming capabilities for automated root cause analysis and remediation.

Agentforce Health Monitoring addresses the gap where traditional dashboards show healthy status while users actually receive no end-to-end response. The system tracks over sixteen built-in metrics including error rates, escalation rates, engagement, and latency, with plans to add cost, time-to-first-token, and RAG quality signals. Its primary goal is proactive visibility that connects alerts directly to the relevant session context.

The engineering team solved a major fragmentation problem by consolidating signals scattered across five or six separate systems. By converting data ingestion to streaming and simplifying query complexity, they accelerated metric evaluation. This optimization reduced the time from a threshold breach to administrator notification from approximately twenty minutes to several minutes, targeting an investigation start time under two minutes.

Operational workflows now emphasize actionable debugging rather than simple detection. Administrators can drill down from an alert to examine specific reasoning steps, tool calls, or flow configurations that caused a failure, and they can define custom thresholds like token usage limits. Looking ahead, the roadmap includes runtime insight agents to suggest fixes and fully automated remediation pipelines that apply approved solutions without manual intervention.

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

Worth reading?