Today24 stories

The Daily Org

Spring '27Sandboxes 6 Feb 2027

Curated by Abhinav (opens in a new tab)

Vol. I · No. 2The independent daily for Salesforce admins, developers and architects24 stories

Must-readAgentforce and AI

How to voice-enable an Agent Script agent with proven best practices (opens in a new tab)

Readers will learn the exact configuration blocks needed to enable voice in an Agent Script agent and how to adjust system instructions for spoken delivery.

Why read this

The guide also covers org prerequisites and deployment steps to avoid common speech-to-text pitfalls.

  1. Verify Agentforce Voice is active
  2. Insert language, telephony, and modality blocks
  3. Rewrite instructions for spoken delivery
A streamlined workflow to voice-enable an Agent Script agent

Before modifying any code, administrators must verify that Agentforce Voice is active in the organization. Once enabled, adding voice capability follows a straightforward two-part workflow that keeps the core agent logic intact while routing conversations through a telephony channel.

Developers need to insert three specific configuration blocks into their Agent Script files. These blocks define the supported language, establish the telephony connection, and select the outbound voice model along with its persona. The nested settings ensure the correct speech synthesis engine handles both incoming audio transcription and outgoing responses.

Because listeners cannot reread text, the system prompts require careful rewriting. Replies must be concise, free of markdown or raw code snippets, and formatted so symbols are spoken as words. The guide emphasizes training the agent to silently correct common speech-to-text errors, such as mishearing technical terms, before providing a final response.

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

Worth reading?

Must-readFlow and admin

Salesforce introduces beta Test Mode for Flow debugging and regression testing (opens in a new tab)

You will learn how to enable and use the new Test Mode beta to save, reuse, and automate Flow validation without leaving the builder.

Why read this

You will also understand upcoming capabilities like element mocking, test coverage tracking, and Agentforce powered troubleshooting.

Traditional Approach

  • Debug button only for troubleshooting
  • Testing and debugging require separate actions
  • Manual checks lack reusable configurations
  • Cluttered design canvas during validation

Test Mode Workspace

  • Dedicated view replaces Debug button
  • Merges debugging and automated testing
  • Saves runs as reusable manual test scenarios
  • Converts manual tests to regression tests with assertions
How Test Mode consolidates Flow debugging and automated testing

Salesforce has released a beta version of Test Mode, a dedicated workspace that replaces the traditional Debug button in Flow Builder. This update merges debugging and automated testing into a single interface, requiring administrators to enable the feature through Process Automation Settings before it becomes available for Record-triggered and autolaunched flows.

The new workspace allows builders to save execution runs as reusable manual test scenarios. These saved configurations preserve triggering records, input variables, and mocked outputs. Administrators can now supply static record identifiers for poorly searchable objects and populate primitive collections directly in the test panel. Once validated, these manual scenarios can be transformed into permanent regression tests by attaching expected results.

Test Mode also introduces element mocking, which simulates outputs for subflows and external actions to keep testing isolated from live endpoints. The roadmap includes Winter ’27 enhancements such as visual test coverage tracking on the canvas and Agentforce powered capabilities. These future features will synthesize transaction context to diagnose cross automation failures and automatically generate comprehensive test scenarios with isolated data silos.

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

Worth reading?

RecommendedAgentforce and AI

Use custom Python chunking to improve Agentforce retrieval accuracy in Data 360 (opens in a new tab)

You will learn how to deploy Python-based Code Extension functions to override default chunking in Data 360 search indexes.

Why read this

The guide demonstrates how structure-aware splitting preserves table headers and speaker labels, resulting in more accurate Agentforce responses.

The article argues that poor chunking, not the language model, is often the real cause when an Agentforce agent misses details from a PDF or misreads a conversation, because retrieved snippets lose their context before the model sees them. Native Data 360 chunking (section-aware and semantic passage extraction) works well for standard content, but it struggles with complex multipage PDFs, dense tables and multispeaker transcripts when character or token-based splitters are used. Code Extension functions let developers deploy sandboxed, stateless Python chunking logic inside the Salesforce trust boundary, authored with the Data Custom Code SDK, deployed via the Salesforce CLI or UI, and wired into search index creation. The authors caution that their regex and pattern-based examples are illustrative happy-path code, not production-grade, and can produce false positives and negatives.

The piece tests three scenarios, comparing native chunks with custom ones. In a quarterly financial report, native splitting left numbers stranded without their column headers, making a growth-rate question unanswerable; a structure-aware function that detects table boundaries and repeats headers in sub-chunks lets the agent give a precise segment comparison. In a recorded escalation call with five speakers, native chunking produced unattributed walls of text, while a sliding-window function over speaker turns (window of 6 turns, stride of 3, capped at 1,500 characters) kept questions with their answers and preserved speaker names and timestamps, so the agent could identify a contractual downtime commitment. In a regulated-sector document, native chunking exposed SSNs, card numbers, emails, phone numbers, medical record numbers and other identifiers in the vector index; a regex pass before chunking masked the standard formats, though proprietary identifiers such as medical record, payer member, case and token numbers passed through until organization-specific patterns were added. The conclusion is that Code Extension is an escalation path for complex data rather than a replacement for native chunking, and it points developers to the documentation, the Code Extension setup in Data 360 and a video playlist to get started.

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

Worth reading?

RecommendedData Cloud

Deploy Python Code Extensions for complex Data 360 batch transformations (opens in a new tab)

You will learn how to structure, validate, and deploy Python scripts as managed Code Extensions within Data 360.

Why read this

The guide also covers connecting these scripts to batch data transforms and monitoring execution through the platform.

Northstar Outfitters faced inconsistent product data across commerce systems and needed a trusted catalog. Native visual transforms could not handle the required standardization, enrichment, and scoring logic, prompting the use of Data 360 Code Extension to run modular Python and PySpark scripts directly on Salesforce infrastructure.

The solution relies on isolated runtime environments where scripts read from and write to designated Data Lake Objects using explicit permissions defined in a configuration file. Developers validate logic locally against sampled data before packaging the script, dependencies, and tests into a deployable archive.

The guide details both Setup interface and Salesforce CLI workflows for uploading packages, selecting compute sizes, and linking the extension to a batch data transform. Execution, scheduling, and logging are handled by the platform, while operators can trigger runs and review history through REST API calls.

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

Worth reading?

RecommendedIntegration

Generate custom Salesforce Connect adapters with AI skills and headless registration (opens in a new tab)

You will learn how to use the platform-salesforce-connect-adapter-generate skill to automatically create DataSource classes for any REST API.

Why read this

The piece also explains how to register the external data source programmatically using the Headless 360 MCP Server instead of manual setup steps.

Custom Salesforce Connect Apex adapters require implementing DataSource.Provider and DataSource.Connection interfaces, which traditionally demands significant Apex expertise and careful handling of field types, pagination, and error contracts. The article introduces the platform-salesforce-connect-adapter-generate skill, an open-source capability that grounds coding agents in this exact framework so they produce syntactically correct and contract-compliant code on the first attempt.

Using a natural language prompt, a developer can instruct an agent like Claude Code or Agentforce Vibes to generate both adapter classes, map json fields to correct datasource datatypes, enforce required ExternalId columns, and wire Named Credentials without hardcoding secrets. The post demonstrates this with a public rail api example, showing how the generated Connection class handles query context and returns a properly structured TableResult.

After deploying the Apex classes via the Salesforce CLI, the article explains how the Headless 360 MCP Server exposes configuration operations as programmatic tools. This allows the same agent to create the external data source definition through an api call rather than navigating the Setup wizard. The author notes that Winter ’27 will expand this approach to cover the full lifecycle of external data sources and standard adapter extensibility.

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

Worth reading?

RecommendedAgentforce and AI

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?

RecommendedApex and platform

Understanding the new Apex heap limits and transition settings in Winter '27 (opens in a new tab)

Readers will learn the exact new synchronous and asynchronous Apex heap limits in Winter Twenty Seven and how to configure non-production orgs during the transition.

Why read this

The piece also explains how larger memory allocations impact transaction scaling, user experience, and downstream system stability.

The Winter Twenty Seven release increases the synchronous Apex heap limit from six megabytes to ten megabytes and raises the asynchronous limit from twelve megabytes to twenty-five megabytes. To manage the transition safely, administrators can use Apex Settings to force non-production orgs to retain the previous Summer Twenty Six limits until code is verified against the new thresholds.

Testing with large compressed files shows that the additional memory allows significantly larger payloads to be processed in a single transaction, though compression algorithms and file structure still dictate actual heap consumption. The author notes that higher memory availability does not automatically improve throughput, as CPU limits and governor constraints remain unchanged.

Larger heaps introduce risks such as overwhelming end users with unfiltered data tables, overloading downstream APIs, or masking existing logic flaws that previously failed at smaller record counts. The article concludes that developers should continue writing code that conserves resources and batches workloads, treating the increased limits as capacity for legitimate growth rather than a target to hit routinely.

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

Worth reading?

RecommendedArchitecture

Connecting metadata and runtime telemetry to prioritize enterprise org remediation (opens in a new tab)

Readers will learn how Salesforce Engineering correlates configuration metadata with production telemetry to identify and prioritize implementation anti-patterns.

Why read this

The piece outlines the architectural patterns used to standardize hundreds of health signals and expose them through headless APIs.

Salesforce Engineering addressed the challenge of monitoring enterprise org health at scale by moving beyond static reports to an in-app experience called Salesforce Health Insights. The team needed to correlate point-in-time configuration metadata with continuously changing runtime telemetry across systems that lack shared identity models.

To solve this, they built a harmonization layer that reconciles fragmented datasets and maps runtime activity to individual metadata components while accounting for traffic volume and seasonality. This architecture maintains clear boundaries between deterministic findings and external operational context, preserving data origin and freshness information.

The initiative expanded from roughly one hundred initial security signals to over four hundred covering process automation, customization, and agentic readiness. Each signal follows standardized metadata rules and remediation guidance derived from the Salesforce Well-Architected Framework and known system hotspots.

Findings are prioritized using operational context such as application CPU usage and peak business hour traffic to determine criticality and required effort. The system uses a headless schema that emits raw JSON for any user interface or agent, supports an MCP interface, and can deliver summaries directly to Slack channels.

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

Worth reading?

RecommendedAgentforce and AI

Tracing retrieval-augmented generation accuracy failures backward through the context pipeline (opens in a new tab)

You will learn how to isolate and fix accuracy failures in a retrieval augmented generation pipeline by tracing errors backward through parsing, chunking, and retrieval stages.

Why read this

The article also outlines Salesforce specific tools and architectures that improve enterprise document processing and query performance.

The authors describe a RAG application that passed standard text benchmarks above 90% but gave customers wrong answers in production. On complex, customer-representative enterprise documents, accuracy fell to about 46%. Errors could start at any stage: parsing, chunking, enrichment, embedding, retrieval, or answer generation. The central point is that an LLM only sees the context the pipeline preserves, so if information was lost earlier, a stronger model or a rewritten prompt will not recover it. The recommended debugging method is to trace each wrong answer backward through the pipeline, checking first whether the needed context arrived intact and then whether retrieval, chunking, or parsing removed it.

On parsing, the article argues that one strategy does not fit every page. Simple prose can go through a fast deterministic parser, while pages with tables, charts, or diagrams need processing that can interpret visual structure and relationships. Multi-page tables should be kept as one logical unit so their headers still apply after a page break. The authors say their Intelligent Parsing approach routes content by complexity at the page level, raising accuracy in a staged benchmark from 65.1% to 84.4%.

On chunking, the authors recommend treating chunk boundaries as units of meaning rather than storage limits. Headers should stay with their tables, diagrams with their explanations, and procedural steps in order, with overlap used when a split is unavoidable. Chunks can be enriched with summaries, tags, structural context, likely user questions, and file-level details such as title and filename. The article also cites SFR Embedding v3, which extends context capacity from 512 to 8,000 tokens, and reports that enriched indexing raised accuracy from 84.4% to 86.8%.

For retrieval, the article warns that the most semantically similar chunk may belong to the wrong product or context. Explicit constraints such as product, region, or customer tier should be applied as metadata pre-filters before similarity ranking. Questions whose answers depend on facts spread across documents may need GraphRAG, which builds a knowledge graph so an agent can traverse multi-hop relationships; the article says it is slated for general availability in November 2026. Each retrieval method should match the question’s shape.

Finally, the authors advise measuring one change at a time against a human-validated end-to-end benchmark, so that each gain can be attributed to a specific stage. They also cover latency: moving payloads under 100 MB from a Spark-based batch architecture to a service-based Just-in-Time indexing architecture cut indexing time three to four times, from more than 30 minutes to about seven to ten minutes.

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

Worth reading?

RecommendedArchitecture

Architecting real-time mobile personalization with server-side decisioning and content zones (opens in a new tab)

You will learn how to separate app instrumentation from campaign configuration so marketers can update experiences without app releases.

Why read this

The piece also explains how to maintain consistent identity resolution and dynamic native rendering across iOS, Android, React Native, and Flutter using server-side decisioning.

The team built a unified architecture to deliver real-time mobile personalization across iOS, Android, React Native, and Flutter. They solved platform fragmentation by establishing consistent schemas and event semantics while allowing each technology stack to use its native rendering capabilities. A bridge layer enables React Native and Flutter to access native APIs through iOS and Android, preserving a single SDK interface for developers.

Developers define stable content zones and register approved native components once. Marketers then configure templates, targeting, and component selection through the Salesforce user interface. The platform serves this metadata via a global CDN, and the mobile SDK applies the rules to dynamically render the correct native element without requiring new app builds.

Real-time identity resolution relies on Data 360 to merge anonymous web, email, and mobile interactions into a single profile during authentication. Decisioning runs entirely on the server, so the SDK only receives final experience instructions rather than raw customer data. Teams can validate targeting and layout using a QR code preview flow that injects live profile attributes into the simulator before launch.

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

Worth reading?

RecommendedData Cloud

How Data 360 compiles governed context for artificial intelligence agents at production scale (opens in a new tab)

Readers will understand how the Agent Context Engine retrieves, reconciles, and packages authorized evidence into token-efficient Context Packs for AI agents.

Why read this

The piece also explains how Data 360 separates runtime state from durable memory to maintain governance across models and channels.

Salesforce Engineering describes how Data 360 assembles governed, authorized context for AI agents without loading an entire enterprise data estate into every prompt. The core challenge is identifying the requester, purpose, authority and freshness needs, retrieving evidence from structured and unstructured sources, reconciling conflicts, and applying access, masking, residency, consent and purpose controls, all within token, latency, freshness and cost budgets. Data 360 serves as a shared runtime foundation across Salesforce, platforms such as Databricks and Snowflake, operational systems and knowledge bases, with data kept authoritative where it lives through ingestion and Zero Copy. The article cites Q2 FY27 production usage of 104.3 trillion connected records, including 81.5 trillion Zero Copy rows.

The Agent Context Engine works in two directions. On the outbound path it moves through six runtime stages: Resolve (identify requester, agent, purpose, authority, entities and freshness), Plan (choose access paths such as relational, search, graph, RAG, streaming and federated), Reconcile (rank evidence while keeping conflicts visible), Govern (apply controls before retrieval or action), Compile (fit evidence, working state, memory and citations into a token-fit Context Pack and action contract), and Learn selectively (return typed interaction traces and decide what to promote, update or expire). On the inbound path, conversations, tool calls, decisions and outcomes return as traces for audit and evaluation. Only approved facts move into durable memory, and only validated outcomes become learnings.

Data 360 separates runtime state into four forms: working context for the current reasoning step, short-term memory for the active trace across turns, long-term memory for approved facts and commitments that belong to the enterprise, and learnings distilled from validated outcomes and corrections. The article stresses that a transcript is not automatically enterprise memory. Trusted Context sits within Salesforce’s Enterprise AI Harness, alongside Trusted Models, Agency, Actions, Governance and Security, and the same governed context reaches Agentforce, custom and partner agents, and SaaS assistants through SDKs, API adapters, MCP and APIs. The authors also report performance results across production retrieval, high-concurrency queries, analytical SQL, ClickBench, TPC-derived and LDBC graph workloads, while noting these are not directly comparable. They propose an Agentic Context Benchmark, which would count a result only when the resulting action is both authorized and completed. New capabilities are planned to begin rolling out in early FY28, with availability varying by product, region and agreement.

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

Worth reading?

RecommendedAgentforce and AI

How Data 360 data graphs deliver trusted customer context to Agentforce (opens in a new tab)

Readers will learn how the engineering team partitions and indexes Data 360 data graphs to resolve complex customer identities while maintaining strict data isolation.

Why read this

You will also see the architectural tradeoffs used to achieve sub-two-hundred millisecond response times for Agentforce interactions.

The engineering team built Data 360 data graphs to solve the context gap for Agentforce by unifying fragmented customer data across accounts, entitlements, and products. Instead of running multiple queries at runtime, the system pre-aggregates relationships into cohesive data products that agents can call directly.

Resolving customer identity required a partitioned architecture that keeps the broader identity graph separate from customer success views. This ensures that prospect data and information belonging to different tenants remain strictly isolated while still supporting complex many-to-many relationships.

Performance was optimized by analyzing access patterns, designing smaller multi-graphs, and building targeted indices to avoid full table scans. The team shifted from static data models to flexible structures that support semantic search and unpredictable agent queries, ultimately achieving median response times under two hundred milliseconds without dedicated autoscaling infrastructure.

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

Worth reading?

Agentforce and AI

Use Agentforce Vibes to audit and update field descriptions for agents (opens in a new tab)

Readers will learn how to use the Agentforce Vibes IDE to automatically inspect Custom Field metadata, identify missing or conflicting descriptions, and apply approved updates without navigating Setup pages.

Preparing metadata for an Agentforce agent requires reviewing objects, fields, and flows rather than cleaning up the entire org. The article introduces the Agentforce Vibes IDE as a conversational workspace where administrators can query and evaluate configuration data efficiently.

By running targeted prompts in plan mode, Vibes retrieves field metadata and flags Custom Fields with ambiguous labels, missing descriptions, or mismatched business concepts. The system generates evidence-based findings and drafts proposed descriptions while strictly avoiding unsupervised modifications.

Administrators review the AI suggestions, approve valid updates through the interface, and separate genuine cleanup candidates from fields that simply require business clarification. The workflow concludes with bulk updates via CSV attachment or individual conversational commands, allowing teams to maintain human oversight while accelerating metadata preparation.

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

Worth reading?

Architecture

Use the account record to anchor identity, access, and onboarding in Experience Cloud (opens in a new tab)

You will learn how to structure Experience Cloud implementations around the account record to automate authentication routing, enforce consistent data access, and simplify multi-organization onboarding without additional deployments.

Introduces the challenge of scaling Experience Cloud portals for multiple independent organizations, each managing its own identity infrastructure and security standards. Relying on separate login paths and manual configurations quickly creates bottlenecks during onboarding.

Proposes using the account record as the central anchor for external user management. The user to contact to account relationship provides a stable context for storing identity provider preferences, authentication configurations, and onboarding status. This design keeps organization scoped policies centralized and easily retrievable.

Details the implementation steps, including configuring Login Discovery to route users based on account level settings instead of presenting multiple login buttons. Data access follows this same model by aligning lookup relationships with appropriate sharing mechanisms like Sharing Sets or standard Sharing Rules. These choices directly impact community license selection and must align with least privilege principles.

Concludes that treating onboarding as a configuration exercise rather than a deployment project allows administrators to bring new organizations online predictably. The approach reduces architectural complexity while maintaining secure, scalable access controls across the portal.

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

Worth reading?

Agentforce and AI

Use Headless Experience Layer to build agentic user interfaces across multiple platforms (opens in a new tab)

You will learn how to implement the Headless Experience Layer to design interactive AI workflows that render consistently across external agentic surfaces.

Why read this

The session also covers practical guidance from Salesforce experts through a live question-and-answer format.

The presentation introduces the Headless Experience Layer as a tool for developing interactive artificial intelligence workflows. By leveraging this layer, developers can create a single workflow definition and deploy it across various agentic environments without rebuilding the interface for each target.

The approach emphasizes delivering consistent and rich user experiences natively on third-party platforms such as Slackbot, ChatGPT, and Claude. This allows teams to maintain a unified design language while extending their Salesforce AI capabilities beyond the standard interface.

The video concludes with a live expert session where attendees can submit technical questions about implementation patterns, configuration requirements, and best practices for scaling these agentic interfaces.

Watch the video at Salesforce Developers on YouTube (opens in a new tab)

Worth reading?

Flow and admin

Replicate the standard Recently Viewed List View inside a Screen Flow (opens in a new tab)

You will learn how to query the Recently Viewed object, merge its results with parent records using the Transform element, and sort the combined data for display in a Screen Flow.

Why read this

This approach replaces the missing native sorting capability in Flow Builder.

The article addresses the limitation of Flow Builder when trying to replicate the standard Recently Viewed List View, noting that direct sorting by view date is unavailable through standard Get Records elements. It introduces the Recently Viewed object as the underlying source that tracks records accessed by each user without requiring explicit user filtering.

The author demonstrates a six-step process starting with a Get Records element to fetch Recently Viewed entries filtered by the Account type. A Transform element extracts the record identifiers, which are then used in a second Get Records element to retrieve full Account data.

Because the original view date field resides outside the Account collection, another Transform element joins the two datasets using the record identifier as the key. The merged collection is subsequently ordered by the Last Viewed Date field using a Collection Sort element before being rendered in a Data Table component.

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

Worth reading?

Architecture

Salesforce updates its Well-Architected Framework with five pillars and an agentic lens (opens in a new tab)

Readers will learn how the updated Well-Architected Framework restructures architectural guidance into five core pillars and applies them to agentic enterprise designs.

Why read this

The piece clarifies the trade-offs architects must balance when integrating autonomous agents alongside traditional Salesforce solutions.

Salesforce has released an updated version of its Well-Architected Framework to address growing architectural complexity and the rise of autonomous agents. The previous three-pillar model focused on trusted, easy, and adaptable solutions, while the new structure expands to five distinct categories.

The revised framework organizes guidance around trust, reliability, operational excellence, resource and cost optimization, and fairness. Each pillar includes a dedicated lens that examines how these principles apply when designing systems where agents can reason and take action across multiple platforms.

The update emphasizes architectural trade-offs, noting that optimizing for one quality often impacts another. Salesforce developed the framework through collaboration with the Office of the Chief Architect and feedback from hundreds of practitioners. The complete guidance is now available on the Architecture Center for immediate use.

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

Worth reading?

Apex and platform

Using Apex frameworks to enforce code quality and platform limits in the AI era (opens in a new tab)

Readers will learn how to structure Apex libraries with strict interfaces and runtime validations to prevent both human and AI errors.

Why read this

The piece also explains how these patterns automatically optimize SOQL and DML usage to stay within Salesforce governor limits.

The article, written by Piotr Gajek, a Senior Salesforce Developer and Technical Architect, introduces Framework-Driven Development (FDD), an approach developed over a couple of years in his Apex Fluently libraries. Its core idea is to move responsibility for code quality and Salesforce governor limits out of individual developers and AI agents and into shared frameworks and the development process. He argues that LLM output is statistically average and often disconnected from the wider architecture, and that shared limits on an org mean one team’s careless generated code can break another’s solution. He describes the phenomena of “meat proxies” and “slop grenades” as reasons why ownership of code becomes unclear.

The approach rests on three rules: frameworks should be idiot-proof and AI-proof, generated code should be optimized for platform limits, and quality should be built in by design. Idiot-proofing uses limited interfaces that expose only permitted methods, such as the SOQL Lib cache module that blocks toList() because of misleading cached results, and the Trigger Lib contexts that allow only relevant actions per trigger phase. Internal validation throws explanatory exceptions with suggested overrides, and documentation and AI-readable skills act as a final safeguard.

For limits, the author highlights Async Lib, which manages queueable, schedulable and batch jobs to avoid the “Too many queueable jobs” error; DML Lib, which builds a dependency graph and commits records in optimized order through a shared Unit of Work; SOQL Lib, which caches queries in static, org or session scope; and Trigger Lib, which batches parent queries from many handlers. Quality by design is reinforced by phase-specific rules and small, single-responsibility classes. He also suggests administrators could benefit when Apex-based logic replaces Record-Triggered Flows. The conclusion recommends combining libraries, context documents and layered testing, with TDD where useful.

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

Worth reading?

Agentforce and AI

Configuring Agentforce Voice settings and telephony flows (opens in a new tab)

You will learn the step-by-step configuration required to enable Agentforce Voice, including tuning voice parameters, connecting telephony and SMS, and routing calls through Omni-Channel flows.

Why read this

The walkthrough demonstrates how an activated service agent handles a customer interaction and automatically creates a case.

The video provides a guided tour of the initial configuration steps for Agentforce Voice. It begins by navigating the voice settings interface where administrators can select from available stock voices and adjust performance parameters such as speed, similarity, stability, and pronunciation.

Next, the walkthrough covers the integration requirements for communication channels. It explains how to configure enhanced chat and microphone capabilities, set up telephony and SMS routing, assign phone numbers, and connect the system to Omni-Channel flows for proper call distribution.

The final segment demonstrates the activation process for an Agentforce service agent. Once enabled, the video shows a live customer conversation regarding a power adapter, illustrating how the voice agent processes the inquiry and automatically generates a new case record in the system.

Watch the video at Salesforce Admins on YouTube (opens in a new tab)

Worth reading?

Releases

Salesforce announces general availability of Web Console as a modern browser-based IDE (opens in a new tab)

Readers will learn how to access and use the new Web Console for inline Apex and Lightning Web Component editing, debugging, and query execution directly inside their org.

Why read this

The article explains the production guardrails, Setup steps, and how it differs from the legacy Developer Console and Agentforce Vibes IDE.

Salesforce has released Web Console as a generally available browser-based integrated development environment. Built on VS Code for the Web and the existing Salesforce extensions, it serves as a modern replacement for the legacy Developer Console while maintaining platform safety standards.

The tool supports core development tasks including inline editing of Apex classes and triggers, viewing and modifying Lightning Web Component files, running anonymous Apex scripts, and executing SOQL queries with optional Performance Plans. Developers can also run test suites, manage Trace Flags for debugging, and navigate the entire metadata tree using the Org Browser.

Access controls differ by environment, allowing read-only inspection in production orgs while permitting direct saves in sandboxes. Administrators can enable the feature through the Setup menu, where it is turned on by default. The announcement clarifies that this lightweight single-org editor targets quick troubleshooting and routine edits, distinct from the heavier virtual machine-backed Agentforce Vibes IDE.

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

Worth reading?

Agentforce and AI

Using Agentforce Vibes Skills to inspect and configure your Salesforce org (opens in a new tab)

Readers will learn how to access the prebuilt Skills library in Agentforce Vibes and use them to inspect, modify, and deploy metadata changes through a plan and verify workflow.

Why read this

The guide demonstrates practical administration tasks like creating reports and Record-Triggered Flows without writing code.

The article introduces Agentforce Vibes as a browser-hosted Visual Studio Code instance configured specifically for Salesforce development and administration. Although it functions as a developer environment, the piece emphasizes its value for administrators by focusing on the Skills feature, which bundles instructions for distinct configuration actions into reusable packages.

Administrators can browse the preinstalled Skills library through the Toolkit menu after launching Vibes from Setup. The system automatically detects verbs in user prompts and maps them to the appropriate Skills, allowing the agent to execute tasks efficiently without manual selection. Users can also manually add new Skills to expand the toolkit over time.

Changes made through Vibes follow a strict plan, verify, and deploy sequence. Modifications are initially written to the virtualized local filesystem rather than directly to the connected org. Administrators review the generated change plan, approve it, and then trigger deployment using built-in commands or conversational prompts, with the agent handling connection tokens and API calls behind the scenes.

The author strongly recommends testing these workflows in trial environments such as Scratch Orgs, Developer Edition, or sandboxes. Example use cases include creating Custom Objects, adding fields, generating Permission Sets, running SOQL queries, and building Record-Triggered Flows. While early deployments may encounter errors or require multiple attempts, the structured approach provides a safe way to explore AI-assisted platform configuration.

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

Worth reading?

Flow and admin

How Flow Tags simplify organization in the Automation App (opens in a new tab)

You will learn how to create tag categories, assign multiple tags to records, and filter your automation inventory using the dedicated Automation App interface.

Why read this

This approach replaces reliance on naming conventions and long Setup menus for faster flow management.

The Winter ’27 release introduces Flow Tags to help administrators manage rapidly growing automation inventories. This feature provides a flexible categorization method that moves beyond relying solely on flow names or folder structures.

Users must navigate to the Automation App to establish Tag Categories such as Business Area or Purpose. Once categories exist, administrators can add reusable tags and apply them to individual flows through row-level actions or directly within Flow Builder during the save process.

The primary value emerges when searching the platform. Administrators can display a Tags column in List Views, filter results by single or combined labels, and open any tag record to see a Related List of associated automations. This entire workflow operates exclusively within the Automation App and does not function from the standard Setup menu.

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

Worth reading?

Flow and admin

Use the new Group Element to organize Flow Builder canvas sections (opens in a new tab)

Readers will learn how to use the new Group Element in Flow Builder to visually organize related components and collapse sections for better navigation.

Why read this

The feature simplifies maintenance without altering execution logic.

Complex Flows often become difficult to navigate as they grow in size and handle multiple processes. Salesforce has introduced a Group element that lets administrators place related components inside a single container directly on the canvas. This visual organization makes it easier to locate specific logic and understand the overall structure.

Users can collapse these containers to hide detailed steps and reduce screen clutter while working on other areas. Expanding the group restores the full view when review or editing is required. The arrangement exists solely for layout purposes and does not modify how the automation runs.

The element supports standard editing operations such as cut, copy, paste, and ungroup. These tools allow teams to quickly restructure diagrams or duplicate entire logical blocks when replicating similar processes elsewhere in the same automation.

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

Worth reading?

Integration

How API-Driven Integration remains essential as AI agents expand into Salesforce (opens in a new tab)

You will learn which three integration APIs form the foundation of Salesforce connectivity and how they support emerging AI agent workflows.

Why read this

The piece also outlines the current certification roadmap and upcoming MuleSoft credential changes.

The video argues that artificial intelligence agents interact with the platform through application programming interfaces rather than user interface clicks, making integration expertise increasingly vital. It identifies three foundational tools that practitioners should master first.

The REST API handles standard create, read, update, delete operations and data queries. The Bulk API processes large scale jobs involving fifty thousand or more records. Platform Events combined with the Pub/Sub API enable reliable publish subscribe messaging between systems.

The Certified Platform Integration Architect certification path serves as a stepping stone toward System Architect and CTA designations. Two MuleSoft credentials will retire on February 1, 2027 while the product line continues to operate. Salesforce now classifies Headless 360 capabilities under Agentforce revenue metrics, reporting annual recurring revenue exceeding one point five billion dollars.

Watch the video at MyTutorialRack on YouTube (opens in a new tab)

Worth reading?