Skip to main content
Glean Actions let agents perform real work on your behalf in connected tools. Instead of only finding information, agents can complete tasks end-to-end by executing actions such as creating tickets, updating records, sending messages, or running queries directly from a conversational request.

​
What are actions?

Actions are reusable operations that Glean can perform in external applications or data systems. Each action describes a specific task, for example, Create Jira issue or Search Snowflake with SQL and the inputs it needs to run successfully. Within a workflow agent, actions are used as steps. As the agent runs, it calls one or more actions to:
  • Read data, such as fetching records or search results from a data source.
  • Write or update data, such as creating tickets, updating CRM records, or editing documents.
  • Orchestrate work across tools, such as drafting emails, posting messages, or coordinating multi-step workflows.
When an action runs, it returns structured output that becomes part of the agent’s memory and can be used by downstream steps. You can use actions to:
  • Automate repetitive tasks: For example, create Jira issues, schedule meetings, update Salesforce records, or file Zendesk tickets without leaving Glean.
  • Run guided, multi-step workflows: Stitch together several actions like read, decide, write so an agent can gather context, make decisions, and then perform updates in your systems.
  • Standardize business processes: Encode best-practice workflows such as incident handling, deal reviews, or onboarding tasks—so teams follow the same steps every time, via agents.
  • Reduce context switching: Let users request a complete outcome, for example, Create a follow-up ticket and share the link directly in Glean, while the agent handles all underlying calls to connected tools.

​
Build agents with actions

Actions are a core building block of every agent. Each workflow agent consists of a trigger plus one or more steps, and most steps are powered by actions. When you build agents:
  • Actions define what the agent can do: The set of actions you add to an agent determine which systems it can talk to and which operations it can perform, for example, search data warehouse and then summarize results, or create and update issues in a tracker.
  • Actions improve reliability and control: Each action has clear inputs and outputs, letting you constrain what the agent is allowed to do and which parameters it must collect from the user or infer automatically.
  • Actions enable richer, end‑to‑end flows: By chaining multiple actions, agents can first gather context (read actions), then perform updates (write actions), and finally respond back to the user with a complete result.
  • Expanded action library = more capable agents: Glean provides a growing library of prebuilt actions across popular tools, for example, GitHub, Salesforce, Google Workspace, Snowflake, Jira, so you can design powerful agents without building every integration yourself.

​
Types of actions

Glean supports several ways to categorize actions. Understanding these helps you pick the right action for your use case and design predictable agents.

​
By behavior

Actions are defined in two primary types, with subtypes for how they execute:
  • Action (write or operational)
    Performs an operation in an external app, such as creating, updating, or posting data.
    • Execution actions run directly within Glean and complete the operation on your behalf.
    • Redirect actions send you to the appropriate external URL to finish the task in that application.
  • Retrieval (read or fetch)
    Fetches information from external applications, regardless of whether that data is indexed by Glean (for example, running a SQL query in Snowflake or fetching metadata directly from a service).

​
By source

Actions are also grouped by where they come from and how you configure them:
  • Actions by Glean
    First‑party actions that provide deep, curated integrations with popular tools and workflows.
  • Actions by datasource (action packs)
    Bundles of related actions for a specific application, for example, Snowflake Actions, GitHub Actions, Salesforce Actions. These packs expose common read and write capabilities tailored to that system.
  • Custom actions
    Organization-defined automations that you or your developers create to support scenarios not covered out-of-the-box. Custom actions are configured in the Developer Portal and then surfaced to agents like any other action.
Together, these action types give you the flexibility to start with prebuilt operations, extend them with datasource‑specific action packs, and fill gaps with custom actions, all within a single, unified experience for your agents.

​
How to use actions?

How you use actions depends on your role.

​
As an end user

End users typically interact with agents, not with individual actions.
  • You ask the agent to complete a task, for example, Create a Jira ticket and link this doc or Run a revenue query in Snowflake and show the result.
  • The agent decides which actions to call, collects any additional details it needs, and runs the steps in sequence.
  • You see the outcome, for example, created ticket link, scheduled event, or query result in Glean, sometimes with in-line execution of write actions where supported.

​
As an agent builder

Agent builders configure which actions an agent can use and how they must be called. At a high level, when you design a new workflow agent:
  1. Ensure actions are available Admins enable and authenticate action packs, for example, GitHub, Salesforce, Snowflake) in the Admin Console so they can be used in agents. For more information, see Actions setup.
  2. Start with simple, instructions-only flows For common use cases, you can often:
    • Choose a trigger.
    • Add one or two key actions.
    • Provide clear natural language instructions.
      Many agents work well with default field mappings and minimal configuration.
  3. Customize fields and parameters for advanced scenarios For each action step, you can control how required parameters are set (fixed values, user input, or AI‑inferred) and what instructions are sent with the action. This lets you constrain where the agent can write, which records it can touch, and how it must behave in edge cases.
  4. Decide when write actions can run without confirmation
    For interactive agents, you can choose whether eligible write actions require user confirmation or can run in-line for a faster experience. Admins first allow specific write actions to run without confirmation, and agent builders then opt in on a per-step basis. For details, see In-line execution of write actions.
  5. Use Plan and execute steps for complex flows When you want the agent to break down an objective into multiple sub-steps and decide which actions to call, you can use the Plan and execute steps action instead of wiring every step manually. This is useful for more open-ended, multi-step tasks where the exact sequence of actions may vary by run.
After configuration, use preview and testing tools to invoke the agent with realistic queries and validate that actions trigger correctly and return the expected results before publishing to users. For a step-by-step walkthrough, see Create your first agent. For more advanced scenarios, developers can also create custom actions in the Glean Developer Portal and then make them available for use in agents. To check the use of actions within agents, you can see the examples documented in Example agents.