📍 Direct Answer

Agentforce is Salesforce's AI-powered autonomous agent platform that allows businesses to build, deploy and manage AI agents that can independently perform complex tasks across Sales, Service, Marketing and more — without constant human intervention.

📍 What Makes It Different

Unlike traditional automation tools like Flow or Process Builder, Agentforce agents can understand natural language, reason through multi-step problems, take actions and learn from context — all powered by Large Language Models (LLMs) grounded in your Salesforce CRM data.

📍 Key Difference

People often confuse these two. Here is the clear distinction:

📍 What Is It?

The Einstein Trust Layer is Salesforce's AI security and governance framework that sits between your Salesforce data and the Large Language Model. It ensures that AI interactions are secure, private and compliant.

📍 What It Does

📍 What Is Prompt Builder?

Prompt Builder is a declarative tool in Salesforce that allows admins and developers to create, manage and deploy reusable prompt templates for AI features — without writing code.

📍 Key Capabilities

• Create dynamic prompts with merge fields from Salesforce records
• Ground prompts in real CRM data (Account, Contact, Case etc.)
• Preview responses before deploying to production
• Manage prompt versions and A/B test different templates
• Assign prompts to specific Agentforce actions or Einstein features

📍 Types of Prompt Templates

📍 What is RAG?

RAG is the technique Agentforce uses to combine LLM intelligence with real Salesforce data. Instead of the AI relying purely on training knowledge (which may be outdated), RAG retrieves relevant live data from Salesforce and feeds it into the prompt before generating a response.

User asks: "What is the status of Case #12345?"

RAG Process:
1. Agent receives question
2. Retrieves Case #12345 from Salesforce CRM
3. Injects case data into the prompt context
4. LLM generates answer based on REAL case data
5. Response returned to user

📍 Why RAG Matters

• Prevents hallucinations — answers are based on real data
• Keeps responses current — uses live CRM data not stale training data
• Enables personalization — every response is specific to that customer

📍 Agent Builder

Agent Builder is the declarative interface in Salesforce Setup where admins and developers create, configure and test Agentforce agents. It allows you to define an agent's identity, capabilities, topics and actions — all without code.

📍 Key Sections in Agent Builder

📍 Topics

Topics are categories of intent that an agent understands. Each Topic tells the agent what kind of requests it can handle. The agent matches user input to the most relevant Topic and then executes the appropriate Action.

Example Topics: Order Management, Billing Queries, Technical Support, Product Information

📍 Actions

Actions are executable tasks the agent performs within a Topic. Actions are backed by Apex classes, Flows, Prompt Templates or external API calls.

📍 Data Cloud + Agentforce

Data Cloud acts as the unified data foundation for Agentforce. It unifies customer data from multiple sources — CRM, website, mobile app, ERP — into a single customer profile. Agentforce uses this unified profile to give AI agents complete context about every customer.

📍 What Data Cloud Provides to Agentforce

• Unified Customer Profile — Complete 360° view of the customer
• Real-time Data — Agent sees the latest customer data not cached snapshots
• Segmentation — Agents can target right customers based on segments
• Calculated Insights — Pre-computed metrics (LTV, churn score) available to agent
• Data Graphs — Relationship maps that give agent context on connected data

📍 Supported Channels

📍 Copilot Action

A Copilot Action is a specific task an Agentforce agent can perform when triggered by a user request through Einstein Copilot. It connects natural language intent to an executable action backed by Apex, Flow or a Prompt Template.

📍 How It Works

User says: "Summarize my top opportunities this quarter"

Einstein Copilot:
1. Understands intent = Opportunity Summary
2. Matches to Copilot Action = "Q1 Opportunity Summarizer"
3. Action runs Prompt Template + SOQL data
4. Returns natural language summary to user

📍 Types of Copilot Actions

• Standard Actions — Pre-built by Salesforce (Draft Email, Summarize Record)
• Custom Actions — Built by your team using Apex, Flow or Prompt Builder

📍 Complete Data Flow with Trust Layer

Step 1: User sends request to Agentforce
Step 2: Einstein Trust Layer intercepts the prompt
Step 3: PII Detection — finds sensitive fields
        (SSN, credit card, health data, email)
Step 4: Data Masking — replaces PII with tokens
        "John Smith" → "[PERSON_001]"
        "4111-1111-1111-1111" → "[CC_001]"
Step 5: Masked prompt sent to LLM
Step 6: LLM generates response using masked data
Step 7: Trust Layer de-masks response
        "[PERSON_001]" → "John Smith"
Step 8: Toxicity check on output
Step 9: Audit log created
Step 10: Clean response returned to user

📍 Key Protections

📍 Steps to Create Apex-Backed Action

Step 1: Create Apex class with @InvocableMethod

global class AgentforceOrderAction {
    
    @InvocableMethod(
        label='Get Order Status'
        description='Returns order status for a given order number'
    )
    global static List<OrderResult> getOrderStatus(
        List<OrderRequest> requests
    ) {
        List<OrderResult> results = new List<OrderResult>();
        for(OrderRequest req : requests) {
            Order__c ord = [
                SELECT Id, Status__c, Expected_Date__c 
                FROM Order__c 
                WHERE Order_Number__c = :req.orderNumber
                LIMIT 1
            ];
            OrderResult result = new OrderResult();
            result.status = ord.Status__c;
            result.expectedDate = String.valueOf(ord.Expected_Date__c);
            results.add(result);
        }
        return results;
    }
    
    global class OrderRequest {
        @InvocableVariable(required=true)
        global String orderNumber;
    }
    
    global class OrderResult {
        @InvocableVariable
        global String status;
        @InvocableVariable
        global String expectedDate;
    }
}

Step 2: In Agent Builder → Add Action
Step 3: Action Type → Apex
Step 4: Select your Apex class
Step 5: Map inputs/outputs to agent conversation
Step 6: Write instructions for when agent should call this action
Step 7: Test in Agent Preview

📍 Flow-Backed Agentforce Action

Step 1: Create an Autolaunched Flow
- Flow type: Autolaunched Flow (No Trigger)
- Add Input Variables (marked as Available for Input)
  example: orderNumber (Text, Input)
- Add Output Variables (marked as Available for Output)
  example: orderStatus (Text, Output)
- Build the Flow logic (Get Records, Assignment, etc.)
- Save and Activate the Flow

Step 2: In Agent Builder → Actions → New Action
Step 3: Action Type → Flow
Step 4: Select your Autolaunched Flow
Step 5: Map Flow variables to agent conversation parameters
Step 6: Add clear Action Description:
  "Use this action when the user asks about 
   the status of their order"
Step 7: Test in Agent Preview → Conversation Simulator

📍 Key Requirement

The Flow must be an Autolaunched Flow — Screen Flows and Record-Triggered Flows cannot be used as Agentforce actions.

📍 What Is Prompt Engineering?

Prompt Engineering is the practice of designing, structuring and optimizing the instructions given to an LLM to get accurate, relevant and consistent responses. In Agentforce, this happens in Prompt Builder through Prompt Templates.

📍 Key Prompt Engineering Techniques

📍 What Are Guardrails?

Guardrails are policy rules that define what an Agentforce agent can and cannot do or say. They act as safety boundaries to prevent the agent from going off-topic, making unauthorized promises, or sharing sensitive information.

📍 Types of Guardrails

📍 Where to Configure

Guardrails are configured in Agent Builder → Agent Instructions section as natural language policy statements and in Topic Instructions for topic-specific rules.

📍 Multi-Turn Conversation Handling

Agentforce maintains conversation context across multiple messages in a session. It remembers what was said earlier in the conversation and uses that context when processing each new message.

Turn 1: User: "I have an issue with my order"
        Agent: "I can help! What is your order number?"

Turn 2: User: "It's ORD-12345"
        Agent: [retrieves order from CRM]
               "I found your order ORD-12345.
                It shipped on April 30. What's the issue?"

Turn 3: User: "It hasn't arrived yet"
        Agent: [already knows order is ORD-12345]
               "I see the expected delivery was May 3.
                Let me escalate this to our shipping team."

📍 How Context Is Maintained

• Each session has a conversation history window
• Previous turns are included in the LLM context on each new message
• CRM data retrieved in earlier turns is cached for the session
• Agent tracks which Topic is active and maintains intent across turns

📍 Data Graph

A Data Graph is a semantic relationship map of connected Salesforce data built in Data Cloud. Agentforce uses Data Graphs to understand how different data objects relate to each other and retrieve complete context about a customer in one structured call.

📍 Example Data Graph

Account (ACME Corp)
    ├── Contacts (3 contacts)
    │     └── Cases linked to each contact
    ├── Opportunities (5 open deals)
    ├── Orders (12 past orders)
    │     └── Order line items
    └── Service History (last 6 months)

When an agent asks about ACME Corp, the Data Graph lets it retrieve all related data in context rather than running 5 separate SOQL queries.

📍 Agent Reasoning Process

User Input: "Can I get a refund for order #456?"

Step 1: TOPIC CLASSIFICATION
Agent reads all configured Topic descriptions
Matches input to most relevant Topic:
→ "Order Management" (confidence: high)

Step 2: INTENT DETECTION
Within "Order Management" topic:
Reads all Action descriptions
→ "Process Refund" action matches intent

Step 3: PARAMETER EXTRACTION
Extracts required parameters from user input:
→ orderNumber = "456"

Step 4: ACTION EXECUTION
Calls the "Process Refund" Apex/Flow action
with orderNumber = "456"

Step 5: RESPONSE GENERATION
Uses response data + Prompt Template
to generate natural language reply

📍 Why Descriptions Matter So Much

The LLM reads your Topic and Action descriptions to decide routing. Poorly written descriptions = wrong action selected. This is why writing clear, specific descriptions is the most important skill in Agentforce configuration.

📍 Testing Methods

📍 Key Things to Test

• Correct Topic is selected for different user inputs
• Correct Action fires within each Topic
• Edge cases — empty order number, invalid customer ID
• Guardrail enforcement — out-of-scope questions are rejected
• Human escalation — triggers correctly when configured
• Multi-turn — context maintained across conversation turns

📍 Human-in-the-Loop

Human-in-the-Loop (HITL) is the mechanism that transfers control from the AI agent to a human agent when the situation requires human judgment, empathy or authorization.

📍 When Escalation Triggers

📍 What Happens on Escalation

Full conversation transcript is transferred to the human agent — they see everything the AI discussed so the customer never has to repeat themselves.

📍 Knowledge Base in Agentforce

Salesforce Knowledge is a primary data source for Agentforce. The agent searches Knowledge Articles when answering questions, providing accurate, approved responses rather than relying purely on LLM general knowledge.

📍 How It Works

User: "How do I reset my password?"

Agentforce:
1. Receives question
2. Searches Salesforce Knowledge for "password reset"
3. Retrieves top matching Knowledge Article
4. Uses article content + Prompt Template
5. Generates clear, friendly response
6. Optionally links to the full article

📍 Benefits

• Responses based on approved company information — not hallucinations
• Always reflects latest policy — Knowledge Articles are maintained by your team
• Reduces case creation — customers self-serve via AI-delivered knowledge

📍 Setup Steps for Service Agent

Step 1: Enable Agentforce in Setup → Agents
Step 2: Create New Agent → Type: Service Agent
Step 3: Configure Agent Identity
  - Name, Role, Tone (Professional/Friendly)
  - Company context and agent persona

Step 4: Add Topics
  - Case Management (create/update/close cases)
  - Order Support (track, return, refund)
  - Technical Support (troubleshoot issues)
  - Knowledge Search (find help articles)

Step 5: Add Actions to each Topic
  - Flow: Create Case action
  - Apex: Get Order Status action
  - Prompt: Summarize Issue action
  - Standard: Knowledge Article Search

Step 6: Configure Guardrails
  "Do not promise refunds over $200 without approval"
  "Escalate if customer mentions lawyer or legal"

Step 7: Set Escalation Rules → Route to Service Console

Step 8: Deploy to Channel → Messaging (Chat widget)

Step 9: Test → Conversation Simulator → Preview

📍 Salesforce Certified Agentforce Specialist

The Agentforce Specialist certification validates expertise in designing, building and deploying AI agents on Salesforce. It is the hottest Salesforce certification in 2026.

Format: 60 multiple choice questions | 105 minutes | Passing score ~65%

📍 Known Limitations

📍 Enterprise Architecture Design

LAYER 1: DATA FOUNDATION (Data Cloud)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
- Ingest CRM data (Salesforce)
- Ingest external data (ERP, website, app)
- Build Unified Customer Profile
- Create Data Graphs for agent context
- Configure Calculated Insights (LTV, churn)

LAYER 2: KNOWLEDGE BASE (Salesforce Knowledge)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
- Organize articles by Topic (matches agent Topics)
- Set up validation for article freshness
- Configure search indexing for fast retrieval

LAYER 3: AGENT CONFIGURATION (Agent Builder)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
- Agent 1: Service Agent (customer-facing)
  Topics: Account, Billing, Orders, Technical
- Agent 2: Sales Agent (rep-facing, Copilot)
  Topics: Pipeline, Email, Meeting, Research

LAYER 4: ACTIONS (Apex + Flow + Prompts)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
- Bulkified Apex for high-volume actions
- Autolaunched Flows for CRUD operations
- Prompt Templates for generative content
- MuleSoft connectors for external systems

LAYER 5: TRUST & GOVERNANCE
━━━━━━━━━━━━━━━━━━━━━━━━━━
- Einstein Trust Layer configured
- Guardrails defined per Topic
- Escalation rules mapped to Service Console
- Audit logging enabled
- Human-in-the-loop for sensitive actions

📍 Multi-Layer PII Protection Strategy

LAYER 1: Einstein Trust Layer (Automatic)
- Automatically masks PII before reaching LLM
- No configuration needed for standard fields

LAYER 2: Field-Level Security (Salesforce)
- Restrict sensitive fields via Profile/Permission Sets
- Agent runs with specific user context — respects FLS
- Never query fields the running user cannot access

LAYER 3: Prompt Template Design
- Never include raw PII fields in Prompt Templates
- Use masked or summarized representations
- Example: Use Account.Name not Account.TaxId__c

LAYER 4: Apex Action Security
global class SecureAccountAction {
    @InvocableMethod(label='Get Account Summary')
    global static List<Result> getSummary(List<Request> reqs) {
        // Check user permissions before returning data
        if (!Schema.sObjectType.Account.isAccessible()) {
            throw new AuraHandledException('Access denied');
        }
        // Never return SSN, Tax ID, or financial data
        Account acc = [SELECT Name, Industry, Phone 
                       FROM Account WHERE Id = :reqs[0].accountId];
        Result r = new Result();
        r.summary = acc.Name + ' - ' + acc.Industry;
        return new List<Result>{r};
    }
}

📍 Debugging Framework

STEP 1: Identify the failure type
→ Wrong Topic selected?
→ Wrong Action fired?
→ Action returned wrong data?
→ Response poorly formatted?
→ Guardrail incorrectly triggered?

STEP 2: Check Topic Descriptions
Open Agent Builder → Topics
Read each Topic description carefully
Rewrite if ambiguous — be more specific
Add example user inputs to Topic description

STEP 3: Check Action Descriptions
Open Topic → Actions
Verify Action description clearly defines
WHEN the action should fire
Bad: "Get order data"
Good: "Use when customer asks about the 
      status, location or delivery of their order"

STEP 4: Test Apex Actions in isolation
Run @InvocableMethod directly via Anonymous Apex
Verify correct data is returned
Check for null handling and edge cases

STEP 5: Check Debug Logs
Setup → Debug Logs → Add user running agent
Run conversation → Check logs for Apex errors
Look for SOQL exceptions or null pointer errors

STEP 6: Use Conversation Simulator
Agent Builder → Test → simulate exact failing input
Check which Topic and Action was selected
Iterate on descriptions until correct routing

📍 Integration Architecture

Option A: Direct Apex Callout
━━━━━━━━━━━━━━━━━━━━━━━━━━━
User → Agentforce → Apex Action → Named Credential
→ HTTP Callout to ERP REST API → Parse Response
→ Return data to Agentforce agent

global class ERPIntegrationAction {
    @InvocableMethod(label='Get ERP Inventory')
    global static List<InventoryResult> getInventory(
        List<InventoryRequest> reqs
    ) {
        HttpRequest req = new HttpRequest();
        req.setEndpoint('callout:ERP_System/inventory/' 
                        + reqs[0].productCode);
        req.setMethod('GET');
        req.setHeader('Content-Type','application/json');
        Http http = new Http();
        HttpResponse res = http.send(req);
        // Parse and return
        Map<String,Object> data = 
            (Map<String,Object>)JSON.deserializeUntyped(res.getBody());
        InventoryResult result = new InventoryResult();
        result.quantity = (Integer)data.get('quantity');
        return new List<InventoryResult>{result};
    }
}

Option B: MuleSoft Integration
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Agentforce → MuleSoft Action → MuleSoft API
→ ERP System → Response via MuleSoft
Better for complex transformations and orchestration

Option C: Data Cloud Streaming
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
ERP → Data Cloud (via streaming ingest)
→ Unified Customer Profile updated in real-time
Agent reads from Data Cloud — no direct ERP callout needed

📍 Governance Framework for Regulated Industries

📍 Industry-Specific Guardrails

• Financial Services: "Never provide investment advice. Always include regulatory disclaimer"
• Healthcare: "Never diagnose conditions. Always recommend consulting a physician"
• Legal: "Never provide legal advice. Escalate all legal questions to human"

📍 Anti-Hallucination Strategy

📍 Migration Strategy

PHASE 1: AUDIT (2 weeks)
━━━━━━━━━━━━━━━━━━━━━━
- Document all current Einstein Bot dialogs
- List all intents (dialog categories)
- Identify all bot actions (what bot does)
- Capture top 20 most common user inputs
- Note escalation rules and conditions

PHASE 2: MAP TO AGENTFORCE (1 week)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Bot Dialogs → Agentforce Topics
Bot Intents → Topic Actions
Bot Variables → Action Input/Output params
Bot Actions → Flow or Apex Actions
Escalation Rules → Agentforce Guardrails

PHASE 3: BUILD IN SANDBOX (3-4 weeks)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
- Create Agent in Agent Builder
- Rebuild actions as Flow/Apex
- Create Prompt Templates for responses
- Configure Einstein Trust Layer
- Set up Knowledge Article linking

PHASE 4: PARALLEL TESTING (2 weeks)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
- Run both bots simultaneously on small traffic
- Compare containment rates side by side
- Tune Agentforce Topics and Actions

PHASE 5: CUTOVER (1 week)
━━━━━━━━━━━━━━━━━━━━━━━━
- Route 100% traffic to Agentforce
- Monitor CSAT and containment daily
- Keep Einstein Bot as fallback for 2 weeks

📍 Scalability Architecture

Agentforce is built on Salesforce's multi-tenant cloud infrastructure which scales horizontally automatically. However, the Apex and Flow actions backing your agent are still subject to Salesforce governor limits.

📍 Key Scalability Considerations

📍 Diagnosis and Fix

Problem: User asks "Can I cancel my order?" 
but agent routes to "Product Information" Topic
instead of "Order Management" Topic

ROOT CAUSE ANALYSIS:
━━━━━━━━━━━━━━━━━━
1. Topic descriptions are too similar or ambiguous
2. "Product Information" Topic description accidentally
   covers order-related language

STEP 1: Review Topic Descriptions
Current "Product Information" description:
"Help customers with questions about products, 
 orders and purchasing"  ← "orders" here causes confusion!

STEP 2: Fix — Make Descriptions Mutually Exclusive
"Product Information":
"Help customers with questions about product features,
 specifications, pricing and availability.
 Do NOT use for order tracking, cancellations or returns."

"Order Management":
"Help customers with questions about their existing orders —
 tracking, cancellation, returns, refunds and delivery.
 Use when customer mentions order number or wants to 
 cancel, return or check status of a purchase."

STEP 3: Add Example User Inputs to Topic
In Topic → add 10 example user phrases that should
route to this Topic — helps LLM learn the mapping

STEP 4: Test All Failing Inputs in Simulator
Verify each one now routes correctly

📍 SDR Agent Architecture

AGENT PURPOSE: Automate outbound prospecting and 
follow-up for the Sales Development team

TOPICS AND ACTIONS:

Topic 1: Lead Research
→ Action: Get Company Info (Apex → Data Cloud)
→ Action: Get Recent News (Apex → external API)
→ Action: Summarize Lead Profile (Prompt Template)

Topic 2: Email Generation
→ Action: Draft Prospecting Email (Prompt Template)
  Inputs: Lead Name, Company, Pain Point, Rep Name
  Output: Personalized outreach email
→ Action: Draft Follow-up Email (Prompt Template)

Topic 3: Lead Qualification
→ Action: Get BANT Score (Apex → Lead scoring)
→ Action: Update Lead Stage (Flow → Update Record)
→ Action: Create Meeting Task (Flow → Create Task)

Topic 4: Pipeline Summary
→ Action: Summarize My Pipeline (Prompt + SOQL)
→ Action: Get Deals at Risk (Apex → Opp analysis)

GUARDRAILS:
"Always personalize emails with specific company context"
"Do not send emails — only draft for rep review"
"Never promise specific pricing in email drafts"

📍 Use Each When

• Use Flow as Agentforce Action — when you need declarative CRUD operations triggered by AI conversation
• Use Apex as Agentforce Action — when you need complex logic, external callouts, or data transformation
• Use Standalone Flow — when triggered by record events, schedules or user button clicks outside of AI

📍 Security Context in Agentforce

Agentforce agents run in the security context of a designated user — called the Running User. This means the agent only has access to data that the Running User has access to.

📍 Best Practice

Create a dedicated Agentforce user with a specific Profile and Permission Sets that grant exactly the access the agent needs — no more. Follow the principle of least privilege.

📍 HR Agent Design

AGENT: "HR Assistant"
AUDIENCE: Internal employees
CHANNEL: Slack, Experience Cloud (Employee Portal)
TONE: Professional, empathetic, helpful

TOPICS AND ACTIONS:

1. Leave Management
   Action: Check Leave Balance (Apex → HR system)
   Action: Apply for Leave (Flow → Create Leave Request)
   Action: Check Leave Status (Apex → Get Leave Record)
   Guardrail: "Cannot approve leave — only employees 
               with manager role can approve"

2. Policy Information
   Action: Search HR Policies (Knowledge Article Search)
   Action: Summarize Policy (Prompt Template)
   Guardrail: "Only answer based on official HR policies
               in Knowledge. Do not interpret or give advice"

3. Payroll Queries
   Action: Get Payslip Info (Apex → Payroll integration)
   Guardrail: "Never share another employee's salary info"
   Escalation: "Route tax or deduction disputes to HR team"

4. Benefits Information
   Action: Get Benefits Summary (Prompt + CRM data)
   Action: Enroll in Benefit (Flow → Update record)

ESCALATION RULES:
- Harassment or discrimination mentions → HR Manager
- Performance dispute → HR Business Partner  
- Medical queries → Benefits team

RUNNING USER: HR_Agent_User
- Read access to HR objects
- No access to payroll details (handled by secure Apex)

📍 Flex Template

A Flex Template is the most flexible Prompt Template type — it can be invoked from Agentforce Actions, Apex code, Flows and APIs. It is the primary template type used to back Agentforce Prompt Actions.

📍 Flex Template Structure

// Example Flex Template for Case Summary

System Prompt (Role Setting):
"You are a helpful Salesforce service agent.
 Your job is to summarize customer cases clearly 
 and professionally."

User Prompt (Dynamic Content):
"Please summarize this customer case:

Case Number: {!Input:caseNumber}
Subject: {!RelatedObject:Case.Subject}
Description: {!RelatedObject:Case.Description}
Status: {!RelatedObject:Case.Status}
Customer Name: {!RelatedObject:Case.Contact.Name}
Priority: {!RelatedObject:Case.Priority}

Provide a 2-3 sentence summary of the issue 
and current status."

📍 When to Use Flex Template

• Backing an Agentforce Prompt Action
• Generating summaries, emails or content in Flows
• Calling from Apex using ConnectApi methods
• When you need dynamic CRM data in your prompt

📍 Continuous Improvement Framework

📍 Tools for Monitoring

• Einstein Copilot Analytics dashboard
• Agentforce conversation transcripts
• Salesforce Reports on escalation volume
• CSAT survey results linked to agent sessions

📍 Deployment Process

STEP 1: Develop in Sandbox
- Build Topics, Actions, Prompt Templates
- Test with real-like data in sandbox
- Document all configuration decisions

STEP 2: UAT (User Acceptance Testing)
- Business users test common scenarios
- QA team tests 50+ edge cases
- Sign-off from stakeholders

STEP 3: Package for Deployment
Agentforce metadata includes:
- Agent definition (metadata XML)
- Topics and Actions configuration
- Prompt Templates (Bot/AI metadata)
- Apex classes (@InvocableMethod)
- Flows (Autolaunched)
- Named Credentials (manually configured in prod)

STEP 4: Deploy via Salesforce CLI or Change Sets
sf project deploy start --source-dir force-app

STEP 5: Post-Deployment Steps
- Configure Named Credentials manually in Production
  (credentials not migrated for security)
- Set Running User for Production agent
- Configure channel (Chat widget, WhatsApp etc.)
- Enable agent → Activate

STEP 6: Smoke Testing in Production
- Test top 10 most common user inputs
- Verify escalation rules work
- Check CSAT baseline

📍 Einstein Copilot Studio

Einstein Copilot Studio is the unified admin interface in Salesforce where you access all AI-related tools for building and managing Agentforce agents and Einstein AI features.

📍 Model Builder — Important for Interviews

Model Builder lets you connect Agentforce to different LLMs:

• Einstein (Salesforce native) — Default, fully Trust Layer protected
• OpenAI GPT-4 — Via Salesforce-managed connection
• Azure OpenAI — For enterprise Azure customers
• Anthropic Claude — Available via Model Builder

📍 Calculated Insights in Agentforce

Calculated Insights are pre-computed aggregated metrics in Data Cloud that the Agentforce agent can access instantly — without running expensive real-time calculations during the conversation.

📍 Examples of Calculated Insights Used by Agents

📍 Why Pre-Compute Matters

Running complex SOQL aggregations during a live conversation would be too slow. Calculated Insights are computed in advance in Data Cloud and served instantly — making agent responses feel fast and intelligent.

📍 Week 1 Greenfield Agentforce Plan

DAY 1: DISCOVERY
━━━━━━━━━━━━━━━
- Interview business stakeholders
  → What are top 5 customer pain points?
  → What requests does support receive most?
  → What takes agents the most time?
- Review existing case/chat transcripts
  → Identify top 20 most common user requests
  → Note exact language customers use

DAY 2: DATA AUDIT
━━━━━━━━━━━━━━━
- Audit Salesforce data quality
  → Is CRM data complete and accurate?
  → What objects will agent need to access?
- Assess Data Cloud readiness
  → Is Data Cloud licensed and set up?
  → Are external data sources connected?
- Review Salesforce Knowledge
  → How many articles? Are they current?

DAY 3: ARCHITECTURE DESIGN
━━━━━━━━━━━━━━━━━━━━━━━━━
- Define 3-5 initial Topics (start small)
- Map required Actions per Topic
- Identify whether Apex or Flow backs each action
- Define Running User and permissions needed
- Plan Einstein Trust Layer configuration
- Design escalation rules

DAY 4: SANDBOX SETUP
━━━━━━━━━━━━━━━━━━━
- Enable Agentforce in sandbox
- Create Running User with correct permissions
- Build Topic 1 only (start with highest volume)
- Create first Action (simplest one first)
- Test Topic 1 in Conversation Simulator

DAY 5: REVIEW AND ITERATE
━━━━━━━━━━━━━━━━━━━━━━━━
- Demo Topic 1 to stakeholders
- Gather feedback on response quality
- Adjust Topic description and Action
- Plan Week 2 scope (Topics 2 and 3)
- Document decisions and rationale