Explore Einstein Copilot
Learning Objectives
After completing this unit, you’ll be able to:
- Define each component of Einstein Copilot.
- Describe what a standard action is.
- Explain how a custom action is built.
A Look Under the Hood
Before Linda starts setting up Einstein Copilot, she wants to get up to speed on the basics of the feature. So let’s join her as she explores the different components and learns what makes Einstein Copilot tick.
How Einstein Copilot Works
Einstein Copilot has three basic components: the copilot, actions, and the reasoning engine.
Copilot
In the previous unit, you learned that Einstein Copilot is a trusted conversational AI assistant seamlessly built into the Salesforce interface. Currently, you can customize and launch one copilot for your employees, and that copilot is available in the flow of work in Salesforce.
Your copilot has the capability to perform business tasks on behalf of the users in your Salesforce org. But how exactly does that magic happen? That’s where actions come in.
Actions
Actions are how a copilot gets things done. A copilot includes a library of actions, which is basically a set of jobs the copilot can do. For example, if a user asks Einstein Copilot for help with writing an email, the copilot launches an action that can draft and revise the email and ground it in relevant Salesforce data.
Salesforce provides some standard actions right out of the box. So after enabling the feature, your copilot is immediately ready to help users with many common Salesforce tasks. But you can also create custom actions to give your copilot additional abilities, so that it can assist with tasks specific to your business. Let’s take a closer look at these two types of actions.
Some Einstein Copilot actions are in beta and have limited functionality, as further described in the Documentation. Including them in a copilot is part of the Services and will consume Einstein Requests if enabled and used.
Standard Actions
Standard actions are provided by default with Einstein Copilot. Some standard actions are available to all users who have permission to access Copilot. Other standard actions were built to work with specific clouds or products, so they require an additional license.
Below are the standard actions that are included with Einstein Copilot, a brief description of what they do, and an example of a user request that might trigger the action. Some of the standard actions are critical for the basic functionality of the copilot, and those are considered system actions. System actions can’t be removed from your copilot.
|
Action Name
|
What It Does
|
|---|---|
|
Identify Record by Name (system action) |
Searches for Salesforce records by name and returns a list of matching records IDs. For example: “Show me the Acme records.” |
|
Identify Object by Name (system action) |
Interprets the user’s input to decide which object the user is referring to, then returns the object’s name so additional actions can be taken. For example, if the user enters, “List the opportunities for the Acme account” in the copilot chat window, the action identifies that user is requesting information related to the Account object and Opportunity object. |
Query Records (Beta) |
Finds and retrieves Salesforce records based on the user’s request and specific conditions, such as the values of fields. For example: “Find all open opportunities set to close this quarter sorted by created date.” |
Query Records with Aggregate (Beta) |
Answers aggregation questions about Salesforce data, such as count, sum, max, min, or average. For example: “How many opportunities were created in the past 5 days?” |
Summarize Record |
Summarizes a single Salesforce CRM record. For example: “Create a summary for the Acme deal.” |
Draft or Revise Sales Email |
Creates a sales email draft or revises the latest generated email based on the user’s input. For example: “Help me write an intro email to Steve from Acme.” |
Answer Questions with Knowledge |
Answers a question from a user based on information from relevant knowledge articles. For example: “What is the policy for returns over 30 days?” (Requires a Knowledge license.) |
As you can see, standard actions are a great start. They give your copilot a set of useful tasks it can accomplish for your employees, and even more standard actions will be available in future Salesforce releases.
If you want to customize your copilot so that it can help users with processes and workflows specific to your business, you can create custom actions.
Custom Actions
The good news about custom actions is that you don’t have to create them out of thin air. In fact, custom actions are based on Salesforce technologies you already know and love.
When you create a custom action, you build it on top of existing platform functionality that you want to make available in Einstein Copilot, such as invocable Apex classes, autolaunched flows, and prompt templates. It’s an awesome way to get more mileage out of your current Salesforce Platform capabilities.
For example, you can use flows to connect to MuleSoft APIs or use Apex or flows to connect to third-party APIs. You can also use Apex or flows to access engagement data, website data, or third-party data through Data Cloud. With custom actions, you can make that functionality available in Einstein Copilot, which unlocks a ton of value and use cases.
Use Cases for Custom Actions
Wondering how your organization might use custom actions? The possibilities are endless, so it depends on the unique needs of your business. Linda has been brainstorming ways Cloud Kicks might take advantage of custom actions. Here are some of the use cases she came up with.
- Get order details.
- Initiate an order return.
- Make product recommendations.
- Check inventory levels.
- Create and modify invoices.
- Book sales meetings.
- Gauge customer sentiment.
- Create marketing materials.
- Log internal IT tickets.
Even though Linda is brimming with ideas, she decides to start small and roll out Einstein Copilot to a small group of users on the sales team to get their feedback first. That way she can test the feature with the standard actions before getting fancy with use cases for custom actions.
To learn more about custom actions, see the links in the Resources section.
Reasoning Engine
Actions are pretty powerful, right? They’re the building blocks of a copilot, the animating force behind your new AI assistant. But how does a copilot know when to launch these actions during conversations with an end user? Let’s meet the reasoning engine behind Einstein Copilot.
You can think of the reasoning engine as the conductor of an orchestra. The conductor keeps time and guides a group of musicians to coordinate their individual performances. Similarly, Einstein Copilot’s reasoning engine orchestrates how actions carry out a user’s request.
When a user launches Einstein Copilot and starts a conversation, they want to ask a question or enter an instruction. Behind the scenes, the reasoning engine works with the LLM to carry out the request. Here’s what it does.
- Interprets the user’s request and determines their intent.
- Dynamically builds a plan for accomplishing the user’s goal.
- Finds and launches the right action or set of actions to achieve the goal.
Fun fact: Einstein Copilot’s reasoning engine has a name—it’s called the planner service. But that’s pretty technical, so we don’t mind if you keep referring to it as a reasoning engine.
Time for Action
Linda’s feeling more confident now that she knows how the feature works, and she’s ready to take Einstein Copilot for a spin. In the next unit, she learns how to enable and customize a copilot in a Salesforce org.
Resources
