> ## Documentation Index
> Fetch the complete documentation index at: https://docs.laneapp.co/llms.txt
> Use this file to discover all available pages before exploring further.

# Agents

> Hand Lane a job and it keeps doing it for you, working from everything your workspace knows: your feedback, customers, priorities and connected tools.

Some of the most valuable product work is the work nobody has time for: reading what changed in feedback before planning, checking that customers actually asked for what engineering is about to build, noticing when a competitor ships what your biggest accounts requested, telling those customers when their request goes live. An agent is how you hand that work to Lane.

You brief an agent once, the way you'd brief a teammate. From then on it does the job by itself, on a schedule or the moment something changes, and tells your team what it found and what it did.

## What makes an agent different

[Ask Lane](/agent) answers you now: you ask, it answers, you decide. An agent keeps a job going without you asking each time, and it does that job with the same understanding of your workspace Lane has in chat:

* **Your customer evidence.** Every [feedback](/insights) item, the [Signals](/signals) they form, the [Opportunities](/opportunities) behind them, and the [customers](/customers) who asked, with their revenue, tier and renewal dates.
* **Your direction.** The goals, focus areas and accounts to watch in your [Context](/context), so it judges what matters the way your team would.
* **Its own history.** Every run remembers the ones before it, so it reports what changed rather than repeating itself, and can follow something up over weeks.
* **Your other tools.** With connectors, it can also read your code, issues, docs, product usage and CRM (see [Connectors](#connectors)).

That context is what turns "summarise my feedback" into "the two things that moved this week, the accounts behind them, and the one that contradicts what we said we'd build next".

## What you can hand an agent

* **A read before planning.** What's rising, what's fading and where customer demand is drifting from your priorities, waiting in your inbox or Slack on Monday morning.
* **A check before building.** When an issue moves into progress in Linear, the agent weighs the evidence behind it (who asked, the revenue behind them, how it fits your focus) and comments on the issue, so the team doesn't build something nobody asked for.
* **A watch on competitors.** It looks for competitor launches and tells you which of your customers asked for the same thing.
* **Closing the loop on releases.** When a pull request merges, it drafts the release notes as a [Doc](/docs), linked to the customers who asked for the change.
* **Docs that keep up.** With Mintlify connected, it proposes updates to your docs as pull requests when the product changes.
* **Deal and renewal prep.** With your CRM connected, it looks at open deals and upcoming renewals and pulls together what those customers have asked for.

These are starting points. If you can describe the job to a teammate, you can hand it to an agent.

## Create an agent

1. In the sidebar, choose **+** next to **Agents**.
2. Start from a template, or choose **Start from scratch**.
3. Set it up: when it runs, its **Instructions**, the apps it can use, and where results go. Changes save as you make them.
4. Choose **‹ Save and back**, then **Run now** to see a result. When it looks right, switch it on.

New agents start switched off, so nothing runs until you're ready. You can also ask Lane in chat ("every Monday, tell me which Signals grew most"), and it sets up a scheduled agent for you once you approve it.

Each agent gets its own icon and colour so you can tell them apart in the sidebar. Click the icon next to its name to pick another.

## When it works

* **On a schedule**: daily or weekly, at the time and time zone you choose.
* **When something changes**: when a Linear issue's status changes (narrowed to certain teams or statuses if you like), or when a pull request merges in GitHub (narrowed to a base branch, such as `main`).
* **On demand**: **Run now** starts it any time, even while it's switched off.

Runs from a change start right away. If several changes land while a run is going, the agent handles them together in its next run. A trigger needs its app connected under **Settings → Integrations** before it can fire.

## Instructions

Write what the agent should do on each run the way you'd brief a teammate: what to look at, what to compare, and what a useful result looks like. For example: "List the three Signals that grew most this week, the customers behind each, and anything that contradicts our current focus."

Because the agent remembers its earlier runs, instructions like "tell me what changed since last week" work as you'd expect. Type **/** to add a skill, a set of steps your team saved in **Settings → Skills**, so every run follows the same method.

## Connectors

On its own, an agent works with your Lane data. Connectors let it look further:

* **GitHub**: code and pull requests. Read only.
* **Linear**: issues. Read, or read and write to comment on and update issues.
* **Mintlify**: your docs. Read, or read and write to open docs pull requests. Nothing is published until someone merges them.
* **Notion**: pages. Read, or read and write to create and update pages.
* **PostHog**: product usage. Read only.
* **Attio** and **HubSpot**: deals, companies and notes in your CRM. Read only.

Notion, Attio and HubSpot are personal connections: the agent uses the account of the person who created it, connected under **Settings → Connections**. The rest are workspace apps, connected under **Settings → Integrations**.

With **Read and write**, the agent makes changes without asking, so turn it on only when the job needs it. Each run makes only a small number of changes per app.

## What an agent can change in Lane

Setting up an agent is your approval, so it doesn't stop to ask before acting. Inside Lane, a run can:

* Create [Docs](/docs), shown in the Docs list as made by Lane
* Rewrite or rename the Docs it created, and add to other Docs
* Create or update [Opportunities](/opportunities)
* Save new feedback when your instructions ask, for example from a Slack thread or a connected app, in the customer's own words
* Leave a short [note](/customers#notes) on a customer, so the next run starts from what this one learned
* Create Signals from [Evidence](/signals#highlights-and-evidence) when your instructions ask
* Link Signals to their work when your instructions ask: an existing [Linear](/linear#link-an-existing-issue) issue or a new one it creates, and [GitHub pull requests](/github#pull-requests-on-signals), or unlink them. Linking or creating a Linear issue changes Linear, so it needs Linear set to **Read and write**; linking a pull request only needs GitHub connected. The Signal then moves as it would if you'd done it: a linked issue accepts it, and with GitHub's [close on merge](/github#close-signals-when-their-pull-requests-merge) a merged pull request can close it.

Beyond linking work, it never edits existing Signals or feedback, and never deletes anything.

## Where results go

Under **Notify**, choose **+ Add channel**:

* **Email**: sends each result to the members you pick.
* **Slack**: posts each result to a channel. Slack needs to be connected under **Settings → Integrations**; see [Slack](/slack).

Notify is optional: every result is also kept on the agent's page. Only successful runs are sent, and each message ends with what the agent changed during that run.

## The agent's page

Open an agent from the sidebar. Its page leads with the work, not the settings:

* **The setup in one line**: what starts it, when it runs next, and the start of its instructions. Choose **Edit** to change anything.
* **The latest run**: the result, with **Show more** for the full report, the agent's thinking, and **What I looked at**, the steps it took to get there.
* **Earlier runs**: every run before it, with when it ran, whether it succeeded and how long it took. Open one to read it in full, including where it was delivered and the credits it used.

A dot next to an agent in the sidebar means it has finished a run you haven't opened yet: green when it succeeded, red when it failed.

## Advanced

* **Web search** lets the agent search and read the public web, which is what makes competitor watching work. It's off by default.
* **Model** sets how much thinking a run gets: a faster model for straightforward jobs, a stronger one for weighing evidence or making judgement calls. New agents start on the fastest.

## Runs and credits

Runs use AI credits from your workspace balance, and web search uses more. If there aren't enough credits when a run is due, it's skipped at no cost. See [Billing](/billing).

## Your first agent

New workspaces start with a weekly Opportunities brief, already switched on and emailed to the person who created the workspace. Edit it, switch it off or delete it like any other agent.

Agents are available on every plan. Contributors don't see them.

## FAQs

**Q: How is an agent different from asking Lane in chat?**\
A: In chat you ask and Lane answers right then. An agent keeps doing a job you've described, on a schedule or when something changes, and remembers what it found before.

**Q: Does an agent ask before it changes something?**\
A: No. Choosing **Read and write** for a connector, or letting it create Docs and Opportunities, is the approval. Keep connectors on **Read only** unless the job needs to make changes.

**Q: Can I run it without waiting for the schedule?**\
A: Yes. **Run now** works any time, even while the agent is switched off.

**Q: Why was a run skipped?**\
A: The workspace didn't have enough AI credits when it was due. Skipped runs cost nothing.

**Q: What happens when I delete an agent?**\
A: Its run history and its memory of earlier runs are deleted too. This can't be undone.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.