Agents
An agent is a saved AI instruction that runs on your graph. It's named, reusable, and executable on demand, on a schedule, or in response to an event.
Screenshot needed: Dashboard Agents tab showing the list view: a few saved agent cards, each with a name, an autonomy tier badge (Observe / Suggest / Act), the last-run timestamp, and a Run now button.
:::
How agents differ from chat
Chat is ephemeral: one question, one answer. Agents are persistent: you define a goal once, then run it repeatedly. Every run produces a task: a durable, auditable invocation with a full trace.
Agents always run under the permissions of the user listed as "run as". No agent can access data that user cannot access. Scope and limits only narrow that further.
Creating an agent
Click New Agent on the Agents tab. The form has five fields:
| Field | What you enter |
|---|---|
| Name | A short identifier, e.g. renewals-at-risk. |
| Goal | The instruction the agent follows on every run. Written like a chat prompt, but saved and reused. |
| Autonomy | How much the agent can do without human approval. Defaults to the safest option (Observe). |
| Scope | Which integrations, tools, entity types, and records the agent can touch. Defaults to everything the run-as user can access. |
| Limits | Quantitative ceilings on tool calls, tokens, cost, and time. |
Save the form and the agent appears in the list, ready to run.
Screenshot needed: The New Agent form with the five fields visible, autonomy dropdown expanded showing the four options.
:::
Autonomy tiers
Autonomy is the most consequential choice you make. It controls which tools the agent can call and which ones require a human to approve before execution.
| Tier | Reads | Writes | Destructive actions | Typical use |
|---|---|---|---|---|
| Observe | Automatic | Not available | Not available | Reports, drift detection, dashboards |
| Suggest | Automatic | Needs approval | Needs approval | Triage assistants: agent proposes, human decides |
| Act | Automatic | Automatic | Needs approval | Routine fixes with a safety net on deletes |
| Act (destructive) | Automatic | Automatic | Automatic | Fully trusted agents in a tightly scoped context |
The dashboard shows a colored badge per tier (Observe gray, Suggest yellow, Act orange, Act destructive red) so you can scan a list and immediately know what each agent is allowed to do.
Screenshot needed: Side-by-side comparison of the four tier badges as they appear in the agent list: Observe (gray), Suggest (yellow), Act (orange), Act destructive (red).
:::
Observe is a real, useful tier. It's not a placeholder. Write tools aren't even visible to an observe-only agent, so it can't accidentally cause damage. Run a new agent at Observe first, review what it does, then raise the tier only when you're confident.
Scope
Scope narrows what the agent can access beyond what the run-as user's permissions already restrict. You can limit to:
- Specific integrations: e.g. only Zendesk, not GitHub
- Specific tools: e.g. only
zendesk_add_comment, notzendesk_close_ticket - Specific entity types: e.g. only
SalesforceOpportunity, notSalesforceContact - Specific records: e.g. only accounts in one segment
Scope only ever narrows, never widens. If the run-as user loses access to an integration after the agent is saved, the agent loses access too. Review your run-as user's permissions before relying on a scheduled agent long-term.
Scope is especially important for agents attached to triggers. A scheduled agent keeps running after you've stopped watching it. Tight scope is the safety rail.
Limits
Limits are quantitative ceilings the platform enforces regardless of what the model decides. Even a correctly-scoped agent can hammer an API or accumulate cost if the model gets stuck in a loop.
| Limit | What it caps |
|---|---|
| Max tool calls | Total tool invocations per run |
| Max tokens | Combined input and output across the orchestrator and any subagents |
| Max cost | Dollar ceiling per run, calculated from model-specific pricing |
| Max wall-clock | Hard timeout from run start |
| Max write actions | Write-tool calls (always zero in Observe tier) |
Hitting any limit ends the run with a clean failure and a clear reason, not an unbounded bill or a hung process.
Tasks: one run, one durable record
Every time you click Run (or a trigger fires), the platform creates a task: one durable invocation of the agent. The task detail view shows:
- The plan the agent declared, as a live checklist with steps marked complete as they finish
- Every tool call with arguments, result, and timing
- Usage: tokens, cost, and wall-clock time
- The final result and every entity the agent touched
Tasks survive process restarts, can be cancelled mid-flight, and remain queryable indefinitely.
Screenshot needed: The task detail view for a completed run: left panel shows the live plan checklist with steps marked done, right panel shows a chronological trace of tool calls and the final result.
:::
Molecule-shipped agents
Some integrations include default agents alongside their tools. When you connect a molecule that ships agents, those agents install automatically and appear in your Agents list with the integration's logo.
If you edit a shipped agent, the platform records your customization and won't overwrite it on molecule upgrades. Uninstalling the molecule removes only un-edited shipped agents. Your customizations stay.
Screenshot needed: Agents list with a molecule-shipped agent visible, marked with an integration logo so users can tell at a glance which agents came from where.
:::
Molecule-shipped agents are a starting point, not a constraint. Edit them freely: your version takes precedence.
Next steps
- Save Your First Agent: a guided walkthrough
- Triggers: fire agents on events, schedules, and webhooks
- Approvals: what happens when a Suggest-tier agent proposes a change
- Built-in Tools:
plan,memory_*, and the other tools every agent gets automatically - Molecules: the integrations that supply tools and entities to your agents