Salesforce Agentforce Specialist

Sending company data to a model creates risk. You learn what the Trust Layer does between Salesforce and the model: masking sensitive values, keeping prompts out of model training, screening output and recording what happened.

• What the Trust Layer sits between
• Masking sensitive data before a prompt leaves
• Zero data retention with model providers
• Toxicity detection on prompts and responses
• The audit trail and what it records
• What the Trust Layer does not do for you

You build A data-flow diagram that follows one prompt through every protection.

Prompt templates put a well-built prompt in front of every user. You work through the template types, what each is for, and where in the platform a template can run, from a record page to a flow.

• Why reusable templates beat ad hoc prompts
• Sales email, field generation and record summary templates
• Flex templates for everything else
• Writing instructions a model follows
• Testing a template with sample records
• Template versions and activation

You build Three prompt templates of different types, tested on real records.

A prompt is only as good as the data merged into it. You ground templates with record fields, related lists, flows and retrievers, and set permissions so each person reaches only the templates and data they should.

• Merge fields and related lists
• Grounding with Flow and Apex resources
• Grounding with Data 360 retrievers
• Permission sets that expose a template
• Field-level security and what a prompt can read
• Spotting weak grounding in the output

You build A grounded template that answers from the current record, with access set per role.

Agents answer from what they can find. This module introduces Data 360 as the layer that unifies company data, and the Agentforce Data Library that points an agent at the right knowledge sources.

• What Data 360 holds and why agents need it
• Structured and unstructured data compared
• Adding sources to a data library
• Keeping library content current
• Who can see what retrieval returns

You build A data library built over a set of real knowledge articles or files.

Retrieval quality decides whether an agent sounds informed or lost. You learn how documents are split into chunks, indexed for search and fetched by retrievers, and how each choice changes the answer an agent gives.

• Splitting documents into chunks
• Building a search index
• Vector search and keyword search together
• Configuring a retriever and its filters
• Reading why a retriever missed
• Using a retriever in a prompt or an action

You build Two retrievers over one data set, compared on the same questions.

Topics decide what an agent will take on, and actions decide what it can do. You write topic scope and instructions that steer the model, and attach actions from flows, Apex and prompt templates with clear inputs and outputs.

• Writing a topic description the model can classify on
• Instructions that narrow behavior
• Standard and custom actions
• Actions built on flows, Apex and prompt templates
• Designing action inputs and outputs
• Keeping topics from overlapping

You build An agent with three topics and tested actions behind each.

Some steps must happen the same way every time. You learn how Agent Script mixes fixed logic with model-driven reasoning, so an agent can follow a required sequence and still answer an open question in natural language.

• Where model reasoning helps and where it hurts
• Fixed steps against free reasoning
• Reading and writing Agent Script
• Branching and required steps
• Combining scripts with topics and actions
• Debugging an agent that skips a step

You build A scripted booking or refund flow that mixes fixed steps with open conversation.

An agent runs as someone, in a place. You choose between employee and service agents, connect agents to channels and the Agent API, and decide which user context an agent runs in so it cannot read or change more than intended.

• Employee agent or service agent: choosing
• Connecting an agent to a channel
• Calling an agent through the Agent API
• The user an agent runs as
• Permissions, sharing and what an agent can read
• Handing a conversation to a person

You build An agent deployed to one channel, with its running user and access reviewed.

Agents answer differently on each run, so you test with sets of cases rather than one chat. You build suites in Testing Center, learn which pieces travel together from sandbox to production, and check the result after release.

• Why agent testing differs from code testing
• Writing test cases for topics and actions
• Running a batch in Testing Center
• Reading failures and fixing the cause
• What an agent depends on when it moves
• Sandbox to production and activation
• Checks to run after release

You build A test suite and release checklist for one agent and its templates.

Live agents need owners. You set up monitoring of conversations, read analytics to see where agents succeed or fall short, and run a cycle of review and improvement so quality keeps rising after launch.

• Who owns an agent after launch
• Monitoring conversations and outcomes
• Reading usage and resolution analytics
• Finding where an agent fails
• Tuning topics, instructions and data
• Policy for models, data and change

You build A monitoring plan with measures, owners and review rhythm for a live agent.

One agent cannot own everything. You judge when to split work among agents, how they pass tasks to each other, and what MCP and A2A are for when agents or tools live outside Salesforce.

• When one agent is not enough
• Splitting work into specialist agents
• Handing off tasks and context
• What MCP connects, and why
• What A2A connects, and why
• Scaling a multi-agent design

You build A multi-agent design with clear roles, hand-offs and the protocols between them.

Combine every layer in one agent: grounded prompts, a data library, topics, actions, tests and monitoring. You design the agent for a real business task, then justify each choice on safety, access and scale.

• Scoping a task an agent should own
• Choosing prompts, data and actions
• Setting the security context and channel
• Testing and releasing the build
• Defining how it will be monitored
• Presenting the design and its limits

You build A working agent with its prompts, data, tests and governance plan.