> ## Documentation Index
> Fetch the complete documentation index at: https://atmet.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.
# Core Concepts: The Essential Building Blocks of Atmet
> Learn the key concepts behind Atmet — agents, workflows, triggers, actions, skills, memory, and more — so you can build automations with confidence.
Before you build your first automation, it helps to understand the vocabulary Atmet uses and the mental model behind it. Every automation you create is composed of a small set of well-defined concepts that work together consistently. This page explains each one clearly so you always know what you're working with — and why it behaves the way it does.
## Concepts
The agent is the AI at the heart of Atmet. It understands your goal expressed in plain language, breaks it into a sequence of executable steps, selects the right tools and integrations, and asks for clarification whenever it needs more information to proceed safely.
The agent is not a simple chatbot — it reasons about your intent, handles ambiguity, and plans across multiple apps and actions. When you describe a workflow in the chat, the agent is the entity building the plan, asking follow-up questions, and rendering the workflow for your approval.
During execution, the same agent runs your workflow deterministically, step by step, every time the trigger fires.
**Key behaviors:**
* Asks clarifying questions rather than guessing when information is missing
* Generates interactive forms, tables, and charts inline in the chat (Generative UI)
* Supports multiple AI models — you can choose the model best suited to each workflow
* Always has access to your workspace memory for context-aware responses
A workflow is a saved automation definition. It specifies a trigger (the event that starts it), a sequence of actions (the steps to execute), and any conditions or branching logic applied along the way.
Once you approve a workflow, Atmet saves it and runs it automatically every time the trigger fires — whether you're online or not. Workflows are the primary artifact you produce when you use Atmet; they represent the "what happens" of your automation, persisted and ready to run indefinitely.
**A workflow consists of:**
* **One trigger** — the event that kicks it off
* **One or more actions** — the steps executed in sequence
* **Optional conditions** — filters and branches that control the flow
* **A run history** — a log of every time it has executed
You create workflows through the agent chat. Once created, you can view, edit, pause, or delete them from the **Workflows** panel.
A trigger is the event that starts a workflow. Nothing in a workflow runs until its trigger fires. Triggers are always tied to a connected integration or a time-based schedule.
**Common trigger types:**
| Type | Example |
| ---------------- | --------------------------------------- |
| App event | New email received in Gmail |
| Message received | New message in a Telegram channel |
| Schedule | Every Monday at 9am |
| Webhook | HTTP POST to a Atmet-issued webhook URL |
| Record created | New row added to a Google Sheet |
Each integration exposes its own set of available triggers. When you connect an app, its triggers become available for the agent to use in your workflows.
A workflow can only have one trigger. If you need the same actions to fire from multiple events, create separate workflows — one per trigger.
An action is a single step the agent performs as part of a workflow. Actions do the actual work: sending a message, creating a record, reading data from an API, updating a spreadsheet, generating content, and so on.
Workflows are made up of one or more actions executed in order. Actions can be conditional — run only when certain criteria are met — and can pass data from one step to the next (for example, using the body of an email as input to a content generation step).
**Examples of actions:**
* Send an email via Gmail
* Post a message to a Slack channel
* Create a task in Notion
* Add a row to a Google Sheet
* Generate an image with an AI model
* Make an HTTP request to an external API
* Update a contact record in HubSpot
Actions are provided by integrations. Each connected app unlocks its own set of available actions for your workflows.
A skill is a reusable agent capability — a packaged piece of knowledge that defines how the agent should approach a specific type of task or context. Skills extend what the agent can do and how it responds in different situations.
There are two kinds of skills:
**System skills** are ready-made capabilities built into Atmet for common business workflows — things like summarizing emails, extracting structured data from documents, or routing messages based on content. You can activate them directly from the Skills library without any configuration.
**Custom skills** are capabilities you define yourself. You describe what the skill does, give it a name, and optionally supply reference documents or rules. Once created, the agent can invoke your custom skill in any relevant workflow or conversation.
Think of skills as teaching the agent how to handle a specific domain well. If you create a "customer support triage" skill, for example, the agent will apply that logic consistently whenever it encounters relevant tasks.
Workspace memory is persistent context attached to your workspace. Unlike a regular chat that starts fresh each session, workspace memory gives the agent long-term knowledge about your environment — so it doesn't need to be re-told the same things every time.
**What workspace memory can hold:**
* **App preferences** — which accounts or folders to use by default within a connected integration
* **Approval rules** — which types of actions always require human review before executing
* **File references** — documents, templates, or data files the agent should reference when building or running workflows
* **Team knowledge** — custom facts, terminology, or business rules specific to your team
The agent reads from workspace memory automatically during every conversation and every workflow run. You manage memory from the **Memory** or **Settings** section of your workspace.
Workspace memory is shared across all members of your workspace. Information added by one member is available to the agent for all other members' workflows.
An integration is a connected third-party app. Each integration provides its own authentication, a set of triggers, and a set of actions that become available to the agent once the connection is established.
Atmet supports 20+ integrations including:
Triggers on new emails; actions for sending, labeling, and replying.
Triggers on new messages; actions for sending messages and media.
Triggers on new messages; actions for posting to channels and DMs.
Triggers on PRs, issues, and pushes; actions for creating issues and comments.
Triggers on new files; actions for creating, reading, and updating documents.
Browse the full catalog of supported apps, triggers, and actions.
To add an integration, navigate to the **Integrations** panel and authenticate using OAuth or an API key, depending on what the app supports.
A run is a single execution of a workflow. Every time a trigger fires, Atmet creates a new run and executes the workflow's steps in sequence. Each run is fully logged — you can inspect every step it took, the data it processed, and the outcome.
**Run statuses:**
| Status | Meaning |
| -------------------- | ------------------------------------------------------------ |
| **Running** | Currently executing |
| **Completed** | All steps finished successfully |
| **Failed** | One or more steps encountered an error |
| **Pending approval** | Paused, waiting for a human to review an approval checkpoint |
You can view all runs for a workflow from its **Runs** tab in the **Workflows** panel. Failed runs include error details to help you diagnose and fix issues.
An approval is a human-in-the-loop checkpoint. For sensitive or outward-facing actions — like sending an email to a customer, deleting a record, or posting to a public channel — Atmet can pause the workflow and ask you to review the proposed action before it executes.
When a run hits an approval checkpoint:
1. The workflow pauses and enters **Pending approval** status.
2. Atmet notifies you (via the app and, optionally, by email or message).
3. You review the proposed action and either **Approve** or **Reject** it.
4. If approved, the workflow resumes from where it paused. If rejected, the run ends and is logged accordingly.
You can configure which action types always require approval in your **Workspace Memory** settings, or instruct the agent to require approval for a specific step when describing a workflow.
If you don't respond to a pending approval within the configured timeout period, the run will be automatically cancelled. Make sure approval notifications are enabled so you don't miss them.
A workspace is your team's shared environment in Atmet. It contains all your integrations, workflows, skills, workspace memory, and members — everything needed to run your automations together.
**Workspace member roles:**
| Role | Capabilities |
| ---------- | -------------------------------------------------------------- |
| **Owner** | Full access; manage billing, delete workspace, assign roles |
| **Admin** | Create and manage integrations, workflows, skills, and members |
| **Member** | Create and run workflows; view integrations and skills |
Each workspace has its own isolated set of integrations and credentials. If your organization has separate teams with distinct tool sets or security boundaries, you can create multiple workspaces.
You manage workspace settings, members, and roles from the **Settings** panel.
## The two-phase model: Builder and Runtime
Every automation in Atmet goes through two distinct phases. Understanding the difference helps you reason clearly about what's happening at any point in the lifecycle.
### Builder phase
The builder phase is everything that happens in the agent chat before a workflow is approved and saved. During this phase, you and the agent are collaborating to design the automation.
* You describe your goal in plain language
* The agent asks clarifying questions and fills in missing details
* The agent proposes a structured workflow plan
* You review, request changes, and ultimately approve the plan
The builder phase is **interactive and iterative**. Nothing executes on your connected apps while you're designing. You can revise the plan as many times as you need before approving.
### Runtime phase
The runtime phase begins the moment you approve a workflow. From this point on, Atmet's execution engine takes over.
* The engine monitors the trigger continuously
* Every time the trigger fires, it creates a new run and executes each step in sequence
* It passes data between steps, evaluates conditions, and pauses at approval checkpoints
* It logs every action taken, every value processed, and the final outcome
The runtime phase is **deterministic and automatic**. The agent doesn't re-reason from scratch on every run — it executes the saved workflow plan faithfully. This makes runs fast, predictable, and auditable.
You can always return to the builder phase by opening a workflow and clicking **Edit**. The agent chat re-activates and you can describe changes in plain language, just like the original design session. Once you approve the revised plan, the runtime updates and future runs use the new definition.
## Next steps
Step-by-step instructions to connect your first app and run your first automation in under ten minutes.
See all available apps, the triggers they expose, and the actions they support.