Stories in Agentforce and AI

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.

Default character or token splitters fracture complex enterprise documents like financial reports and call transcripts, causing Agentforce to retrieve contextless chunks. The article explains how Data 360 Code Extension functions allow developers to run custom Python scripts within the Salesforce trust boundary to implement tailored chunking logic.

For fragmented data tables, standard chunking strips column headers, leaving raw numbers meaningless to the model. A custom function detects table boundaries and repeats header rows across sub-chunks, enabling the agent to correctly map values to metrics like revenue and operating margins.

Multispeaker dialogues suffer when speaker turns merge into massive unstructured blocks. By applying a sliding window approach with defined turn counts and character limits, adjacent chunks overlap to preserve conversational context. The author validates these techniques by querying both native and custom vector indexes and comparing the resulting Agentforce answers against identical user prompts.

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.

The engineering team discovered that standard benchmarks masked severe accuracy drops when processing complex enterprise documents. They resolved this by treating end-to-end accuracy as an opaque metric and instead debugging the pipeline backward. By isolating each stage from source ingestion to answer generation, they identified where meaning was lost during parsing or chunking rather than blaming the large language model.

The solution required routing simple text through fast deterministic parsers while using model-based processing for pages containing tables, charts, or diagrams. Chunking strategies shifted from fixed token limits to semantic boundaries that preserve headers, diagrams, and procedural sequences. Enriching chunks with metadata and question representations, combined with the extended context capacity of SFR Embedding v3, significantly improved retrieval fidelity.

Retrieval accuracy increased by applying dynamic metadata pre-filters before semantic ranking and preparing for GraphRAG to handle multi-hop questions across connected facts. The team also replaced batch indexing with a Just-in-Time architecture to reduce latency for smaller payloads. Continuous staged evaluations allowed them to attribute accuracy gains to specific changes, ultimately raising enterprise document accuracy above ninety percent.

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.

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.

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.

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.

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.

Salesforce engineers describe building Assistive Authoring for Prompt Builder, which turns a plain-English requirement into a working Prompt Template in under a minute instead of the roughly 25 minutes an experienced admin needs today. The core risk they targeted was not obviously bad output but plausible-looking templates that break at runtime because the model invented a field, corrupted a record ID, or returned malformed metadata.

The solution uses Agent Graph to split the work into a router node and three specialized sub-agents for generating, refining, and clarifying requests. State variables carry client-supplied and runtime context, bound inputs pass only what each tool needs, and four backend tools run in a fixed sequence with a beforeReasoning hook that fetches grounding before the model loop starts, cutting latency by removing a model decision from the critical path.

Deterministic boundaries protect the three failure points. The model can signal intent through a state variable, but the graph evaluates guards before changing nodes. The model never touches record IDs; it writes stable developer names and a server-side transpose layer maps them back to real records and IDs. Template metadata is wrapped in sentinel tags, the client extracts and parses only that payload, and parse failures return errors rather than guesses.

Grounding is handled by a discovery service that normalizes SObject fields, flows, Apex-backed providers, and search retrievers into one consistent shape, runs in the current user’s context with field-level readability filtering, and reduces the result to an allowlist the model must select from. Safety is enforced by making output a draft only: the agent has no tool to save, publish, or execute, content becomes typed editor blocks with escaped interpolation, and the admin accepts or rejects a diff before anything is saved.

The article profiles Agent Designer, an internal Marketing Cloud system that automates the design, verification, testing, and repair of multi-agent AI teams, reducing the cycle from two to four hours to roughly 15 to 30 minutes. Engineers previously hand-authored YAML files, prompts, profiles, tools, models, budgets, and turn limits, then tested and iterated manually. The new system uses an orchestrator that dispatches and verifies work but is prohibited from writing any agent file, supported by seven specialists that each carry their own model, budget, and turn limit, and it has helped about 200 engineers adopt a manager-of-agents model.

Multi-agent governance proved harder than single-agent configuration because independently valid specialist outputs can combine into an unbuildable design. Architecture, failure-mode, and compliance analysts work in parallel without seeing each other’s findings, so the orchestrator must detect contradictions and apply bounded remediation rather than restarting the analysis. Since the agent specification lacked a native write-scope field, write boundaries are enforced in prompts, and teams created through Claude Unleashed must define exactly one coordinator and pass a compatibility validation.

Budget enforcement is topology-specific: a flat check for a single agent, items times cost times steps for a swarm, and whole-roster ceilings for a team, all fitting inside the orchestrator’s 500-turn budget that is divided across analysis, approval, generation, testing, and retries. Verifiers return structured PASS, WARN, or FAIL blocks with rules such as warning rather than failing when uncertain, and the orchestrator runs a meta-check across their outputs. A test doctor classifies failures into categories including soft failures that require point-by-point comparison against expected behavior, and self-healing is capped at two fix attempts and a three-dollar ceiling before the system stops and escalates to a human.

Agentforce Coworker is presented as one of three pillars of AIforce, the interface layer announced at Dreamforce ’26 that sits on top of Agentforce, Customer 360 and Data 360. Its purpose is to reduce swivel-chairing between applications and to act as a router for a growing agentic workforce, so users do not have to know which agent handles which task. It offers three interaction modes: Find for natural-language queries across CRM, Slack, files, knowledge bases and 270+ connected sources; Catch Up for proactively surfacing changes that occurred while the user was away; and Plan and Act for outcome-level instructions that Coworker orchestrates across agents.

The article describes the trust model as reusing the existing Salesforce metadata-driven security: Profiles, Permission Sets and Sharing Rules still apply, so the agent operates under the same least-privilege constraints as users. Setup requires Data 360 to be enabled first, since it indexes CRM data and enforces governance, then assigning the Agentforce Coworker Admin Permission Set, enabling the feature through Salesforce Go, optionally granting additional data sources under Manage Data, and finally assigning the Agentforce Coworker User Permission Set to end users. The author cautions that orgs need clean data and properly configured permissions before enabling it, and notes the user-facing entry point is a new Ask button next to global search in Lightning Experience, with availability also in Microsoft Teams.