Agentforce Interview Questions

• AgentForce is Salesforce’s AI-powered automation system.
• It uses AI Agents to perform tasks based on user prompts.
• Combines LLMs + Copilot + automation tools (like Flows, Apex, etc.).

• Traditional tools like Flows need clicks or buttons.
• AgentForce uses natural language commands.
• It can plan, act, and complete tasks autonomously.

• AI Agents are like smart assistants inside Salesforce.
• They can understand user goals, plan steps, and take action.

        Example: Drafting emails, updating records, running flows.

• Copilot is the interface between the user and AI Agent.
• It listens to prompts and translates them into actions.
• Think of it as the chat-based front end of AgentForce.

• A goal is what the user wants to achieve (e.g., "send a follow-up email").
• The agent breaks the goal into steps and tasks.
• Each goal is matched to one or more Copilot Skills.

• Reduces manual work (no clicks or forms).
• Understands natural language, saves time.
• Automates multi-step actions from a single prompt.
• Enables users to focus on business goals, not steps.

• They use Copilot Builder and skills catalog to match tasks.
• Based on the user prompt + system configuration.
• Agent then uses Flows, Apex, or APIs to complete actions.

• A prompt is what the user types or says (e.g., "log a call").
• It helps the agent understand the intent.
• The prompt is processed by an LLM and grounded in Salesforce data.

• Flows require manual setup and specific triggers.
• AgentForce can act based on conversation and context.
• It chooses the right tools (like Flows) on its own, based on the goal.

• Einstein Copilot is a conversational AI assistant inside Salesforce.
• It understands natural language prompts from users.
• It interprets the request, finds the right skill, and executes tasks like updating records or sending emails.
• Copilot acts as the interface between user and AgentForce.

• It’s a setup tool to configure and manage your Copilot.
• Admins can define what Copilot can do (skills, permissions, data access).
• Enables linking Flows, Apex, APIs, and Prompt Templates to user prompts.

• Go to Copilot Builder > Data Access Configuration.
• Add Lead object to the Copilot’s allowed data scope.
• Define skills or actions related to Leads (e.g., “Show all open leads”).
• Use Prompt Builder to fine-tune responses.

• Skills are reusable blocks of logic Copilot can execute.
• Can be built using Flows, Apex, or External Actions.

        Example: “Create a Case”, “Send email”, “Update opportunity stage”.

        Copilot chooses the skill based on user goal.

• Copilot Actions are the building blocks of Skills.
• They represent steps the AI can perform (e.g., create record, send email).
• Often linked to invocable Flows or Apex methods.
• Skills = Sequence of Actions to complete a goal.

• Prompt Builder helps create and manage prompts and responses.
• You define how Copilot should respond to certain types of input.
• Supports grounding, role-based customization, and testing.

        Example: Customize how Copilot replies to "Show my open cases".

• Copilot is goal-driven, not just conversational.
• It can take real actions in Salesforce (like a smart assistant).
• Works with Flows, Apex, and data — not just text replies.
• Chatbots are often limited to FAQ-style responses.

• Yes — you can control data access, actions, and visibility by role.
• Copilot Builder allows profile- or permission-based control.
• You can have different skills/prompts for sales vs service users.

Copilot Actions can be built from:

• Flows (Invocable Flow).
• Apex (Invocable methods).
• External Services (API calls via OpenAPI spec).
• You register these in Copilot Builder > Skills & Actions.

• Use Copilot Debug Mode to trace steps taken.
• Check Skill logs, Prompt history, and Apex/Flow debug logs.
• Validate if required permissions or data access are missing.
• Adjust Prompt Builder settings or Flow logic if needed.

• LLM = Large Language Model (e.g., GPT, Claude, etc.).
• It understands and generates human-like responses.
• Copilot uses an LLM to interpret user prompts like “Update this opportunity.”
• It turns natural language into actions, queries, or instructions.

• A prompt is the text instruction or question given to the LLM.
• It helps the LLM understand what the user wants.
• Example: “Send follow-up email to all open leads.”
• A well-written prompt gives clear intent and context.

• Be clear and specific (e.g., "Update stage of closed-won opportunities”).
• Use action words like “create,” “show,” “update,” “summarize.”
• Add filters or conditions (e.g., “only for this month”).
• Avoid vague instructions like “Do it” or “Handle everything.”

• It’s the process of connecting AI to real Salesforce data.
• Helps ensure the AI uses accurate, up-to-date information
• Prevents the model from guessing or hallucinating.

         Example: Instead of generating a fake lead count, it queries actual lead records.

• “Create a new Case for this customer.”
• “Summarize last 3 meetings with Acme Corp.”
• “Update all Opportunities over $10K to stage ‘Proposal’.”
• “Send follow-up email to attendees from Hyderabad summit.”

• Hallucinations = AI makes up incorrect or fake information.

Salesforce avoids this using:

• Prompt grounding (use real data).
• Trust Layer (enforces permissions).
• RAG (fetches actual data before answering).

• A method where AI retrieves real data before generating a response.
• Combines search + generation = more accurate answers.
• Used by Copilot to avoid hallucinations.

Example: Copilot finds actual leads and then summarizes them.

• It uses the Einstein Trust Layer to enforce user permissions.
• Data grounding and RAG ensure accurate, secure data usage.
• Copilot only responds with data the user has access to.
• Tokens and APIs are protected via Shield, Field-level Security, etc.

•  Not directly inside Salesforce.
• You can integrate external LLMs using APIs (e.g., OpenAI, Anthropic).
• Salesforce provides its own trusted LLMs via Copilot.
• Customization is done using Prompt Builder, Skills, and Actions, not model training.

• A Skill is a task or goal Copilot knows how to perform.
• It uses Flows, Apex, APIs, or Actions under the hood.
• A Flow is a tool to automate logic; a Skill wraps it with intent and AI context.
• Skills are selected by Copilot, Flows must be manually triggered otherwise.

• Use Copilot Builder to create a Skill.
• Link multiple Copilot Actions (like Flow steps or API calls).
• Define the sequence and logic in the Skill config.
• Example: "Create Opportunity → Assign Owner → Send Email" = one Skill.

• A goal is what the user types/says (e.g., “Follow up with all leads”).
• Copilot maps that goal to a Skill based on prompt matching.
• The Skill contains Actions (Flows or logic) to complete the goal.
• Copilot handles the conversion automatically using LLM + grounding.

• Use Copilot Debug Mode (in Setup or Dev tools).
• Check logs for the Skill and its linked Actions.
• Review prompt inputs, output, and Flow errors.
• Use Flow debug logs or Apex logs for deeper issues.

Based on the user prompt, Copilot matches to a Skill using:

• Prompt content
• Intent mapping via Prompt Builder
• Role or app context
• If multiple matches, Copilot picks the best fit or asks for clarification.

• In Copilot Builder, create a Copilot Action that references the Flow.
• The Flow must be invocable and follow required input/output format.
• You can use the same Flow in multiple Skills across apps.
• This ensures modularity and reusability.

• Copilot uses confidence scoring to choose the best match.
• If the match is unclear, it may ask clarifying questions.
• Admins can define priority or conditions in Prompt Builder.

Example: Two "send email" Skills → Copilot may ask "For which object?"

• Yes.

Skills can call:

• Apex Methods (invocable)
• External APIs (via External Services or Apex callouts)
• Custom components via Actions or Flow subflows
• This makes Skills extensible and powerful for any use case

• RAG is an AI method that retrieves real data before generating a response.
• It improves accuracy and trust in AI outputs.
• Copilot uses RAG to pull real Salesforce records before replying.
• This avoids “hallucinations” or made-up answers.

When a user enters a prompt, Copilot uses RAG to:

• Understand the prompt via LLM.
• Query Salesforce data (e.g., Leads, Opportunities).
• Use the result to build an accurate response.
• All this happens in real time and securely.

• A protective layer that ensures Copilot respects Salesforce security rules.
• Enforces field-level, object-level, and record-level permissions.
• Filters what Copilot can see or return based on user access.
• Prevents Copilot from leaking sensitive or restricted data.

• It ensures Copilot only returns data the user is allowed to view.
• Applies all sharing rules, profile-level access, and org security policies.
• Works with RAG to filter both what’s retrieved and what’s shown.
• Protects against accidental exposure of private information.

• Grounding means connecting the LLM to actual business data.
• Ensures the AI doesn’t “guess” but uses factual info from Salesforce.

Example: Instead of generating a random opportunity count, Copilot queries Salesforce.

• Copilot can use Data Cloud as a source of unified, real-time data.
• Data Cloud brings together external, CRM, and 1st/3rd-party data.
• RAG uses this data to ground prompts across sources, not just CRM.
• Enables cross-cloud, customer-wide insights.

• Yes — if data is brought into Data Cloud or made available via External Services.
• RAG can be configured to pull from custom connectors or external APIs.
• All external data must comply with Trust Layer rules and permissions.
• Helps in 360° customer view and AI enrichment.

• Controlled by user’s profile, sharing rules, and field-level security.
• Admins configure data access in Copilot Builder > Data Access Settings.
• Trust Layer applies this access control during grounding.
• Also customizable via custom prompts and filters.

• Copilot will not return the data if access is restricted.
• It may return a generic message like “You don’t have permission.”
• The Trust Layer silently filters out restricted results.
• Keeps the experience secure without exposing sensitive info.

• Fields hidden by FLS are automatically excluded from Copilot’s answer.
• Even if the record is visible, sensitive fields (like Salary or SSN) won't show.
• RAG respects all FLS, object permissions, and role-based access.
• This keeps Copilot answers safe, filtered, and compliant.

• AgentForce respects existing Salesforce security settings.
• Enforces object, field, and record-level access (OWD, roles, sharing rules).
• Works through the Einstein Trust Layer to ensure safe responses.
• Copilot only acts within what the user is allowed to do/view.

•  No — Copilot cannot access or show restricted data.
• Trust Layer ensures all responses are filtered by user’s permissions.
• If data is restricted, Copilot may return a limited or blank response.
• This prevents data leakage or exposure.

• It’s a security layer between Copilot and Salesforce data.

Checks every prompt response for:

• • Object/field access
  • Sharing rules
  • FLS and org-wide settings
• Filters results so users only see data they’re authorized to access.

• Salesforce Shield adds encryption, monitoring, and event logging.
• Field Audit Trail tracks changes made via Copilot or AI agents.
• Helps organizations meet compliance, legal, and audit requirements.
• Useful for data access review and history tracking.

Admins can control:

• Who can use Copilot (via Permission Sets).
• Which objects/actions are allowed.
• Which prompts and data scopes are enabled.
• Copilot can be scoped by profile, app, or skill visibility.

• Use Prompt Builder or Copilot Builder to limit skill availability.
• Apply Permission Sets or role-based conditions.
• Skills can be hidden if user lacks required object or field access.
• Ensures Copilot runs only authorized business logic.

• Audit logs record what Copilot did, when, and for whom.
• Tracks AI-driven actions, changes, or record updates.
• Stored securely for compliance, rollback, or incident review.
• Can be extended with custom logging via Apex/Flows.

• Use Audit Trail, Field History Tracking, or Custom Logs.
• Copilot actions are executed as the user, maintaining accountability.
• Admins can trace activities by timestamp, object, or user ID.
• Helps with troubleshooting and compliance audits.

• Yes — use Permission Sets or profile-level access control.

You can restrict:

• • Copilot access completely.
  • Specific Skills or data objects.
  • Prompt visibility based on role/app.
• Ensures Copilot access is tailored to business need.

• Review data access rules (OWD, FLS, role hierarchy).
•  Configure Prompt Builder with clear intent limits.
•  Enable audit and monitoring (Shield, Login History, etc.).
•  Use Named Credentials and OAuth for external calls.
• Test Copilot with non-admin users to ensure proper access control.

• Create a Copilot Skill with an invocable Flow or Apex to update the Opportunity.
• Use Prompt Builder to map phrases like “Update stage to Proposal.”
• Enable access to the Opportunity object in Copilot Builder.
• Ensure record-level access is enforced by the Trust Layer.

• Build a Flow to generate and send the renewal email.
• Wrap it in a Copilot Skill and map prompts like “Send renewal email to this customer.”
• Use dynamic email templates and auto-fill fields via Flow inputs.
• Optionally, add a confirmation step before sending.

• Create a Skill that uses Apex or Flow to query activity history, cases, and emails.
• Format the response using Prompt Templates.
• Ground the summary in actual Salesforce data (via RAG).

Example Prompt: “Summarize all recent interactions with John Doe.”

• Yes — use a Skill with multiple invocable actions or subflows.
• Example: Create a Contact → link to Account → create Task → send email.
• Copilot handles multi-step logic using goal → actions mapping.
• All steps must respect user’s CRUD & sharing access.

• Create a Flow that starts a standard approval process.
• Expose it via a Skill: “Send this Opportunity for approval.”
• Add branching logic if manager approval is needed
• Copilot submits on behalf of the user with real-time status feedback.

• Define top sales tasks:
  • “Show my pipeline,”
  • “Remind me to follow up,”
  • “Send quote,” etc.
• Build Skills for each task using Flows, Apex, or External Services.
• Customize prompts, permissions, and visibility by sales role.
• Include daily summaries or smart nudges via scheduled prompts.

• Create a Skill with multiple steps:
  • Create a Case
  • Use File Upload Action (standard in Flows)
  • Send Email or Notification to Manager
• Map prompts like: “Log a high-priority support case with details.”
• Use dynamic branching to guide the user for file or notes.

• Yes — Copilot can be embedded in Experience Cloud sites.
• You can expose limited Skills for customers (e.g., check case status).
• Must ensure data and security settings are carefully scoped.
• Use guest user setup, Shield, and FLS control for public Copilot usage.

• Track metrics like:
  • of prompts used
  • Avg. task completion time
  • Errors or retries
• Use Audit Logs, Prompt Analytics, or custom Flow logs.
• Gather user feedback and compare with manual process baselines.

• Pilot launch with small user group (1–2 use cases).
• Refine Skills and Prompts based on feedback.
• Set up training + documentation for broader rollout.
• Assign Permission Sets by role.
• Monitor usage via Copilot dashboards and audit logs.

• Agentic AI = AI that can think, decide, and act like a smart assistant.
• In Salesforce, it means AI agents that interpret user goals and complete tasks.
• Uses LLMs + tools (Flow, Apex, RAG) to take actions, not just give answers.

        Example: Copilot that can plan and execute multi-step tasks like a human assistant.

• Traditional automation (Flows, Process Builder) = predefined rules and triggers.
• Agentic AI = goal-driven, not rule-driven.
• It can choose tools, ask for more info, and adapt.
• Acts based on context and user intent, not just hardcoded logic.

• Yes — agents can execute Skills made of multiple steps/actions.
• They can delegate tasks to sub-skills or subprocesses.
• This is like chaining Flows + Apex + APIs to complete complex workflows.
• Example: One agent handles onboarding → another sends welcome email.

• Based on the user’s prompt and intent.
• Uses Prompt Builder + AI scoring to match a Skill.
• Evaluates context, available data, and access rights.
• If unsure, may ask for clarification before acting.

• Yes — if the prompt is vague or has missing info.
• Copilot can prompt: “Which opportunity do you mean?”
• Supports follow-up questions to refine the goal.
• This makes interactions more accurate and human-like.

• Copilot will:
  • Ask follow-up questions, OR
  • Show options to select, OR
  • Say “I need more info to complete this task.”
• It avoids guessing to prevent wrong actions.
• This is handled through LLM + prompt grounding logic.

• Self-correction = AI detects its own mistakes and adjusts.

Example: “Oops, I created the wrong record — let me fix it.”

• Currently limited in Salesforce (as of 2025), but partially supported through:
  • Prompt chaining,
  • Retry logic,
  • Skill fallback handling.

•  Not natively (Copilot is stateless for now).
• However, admins can analyze usage and refine:
  • Prompts
  • Skill logic
  • Custom actions
• Salesforce roadmap includes feedback loop support in future releases.

• Uses RAG (Retrieval-Augmented Generation) to pull real data.
• Applies the Einstein Trust Layer for secure, grounded responses.
• Copilot only shows data user has access to, not LLM guesses.
• Combines AI generation + strict data filtering.

• Personalized Copilot experiences by role or industry.
•  Closed-loop learning: Copilot adapts to user feedback.
• Agent collaboration: Multiple agents handling end-to-end processes.
• External AI integrations: Custom LLMs, voice, generative UI.
•  Metrics-based optimization: Auto-suggested improvements to Skills.