Skip to main content
An automation is a rule that launches an agent when something happens. It connects a trigger (what happened) to instructions (what to do) and permissions (what the agent is allowed to do). Automations do not do the work themselves — they spin up coding agents that operate inside your environment and report back with results.

Common use cases

Sentry error triage

Investigate production errors, identify root causes, and propose fixes automatically.

GitHub issue response

Reproduce bugs, draft responses, and suggest code changes.

Linear ticket automation

Triage new tickets and take a first pass at implementation.

Intercom support triage

Route high-impact support tickets to agents for faster resolution.

PostHog session replay

Watch replays, identify root causes, and suggest code changes.

Scheduled maintenance

Run recurring tasks like dependency updates, report generation, or cleanup.

Triggers

Triggers are the starting signal. When a trigger fires, Proliferate launches an agent and passes the right context so it can act immediately. There are two kinds of triggers:
  • Events — Something happened (an error, a ticket, a message).
  • Schedules — Something should happen on a cadence (daily, weekly, etc.).
SourceTrigger examples
SentryErrors, new issues, high-severity incidents
LinearNew tickets, status changes, tagged issues
GitHubIssues, pull requests, comments, pushes
PostHogProduct events, user behavior webhooks
SlackMentions, messages, reactions
WebhooksAny system that can send an event, including Intercom
SchedulesRecurring cadence (hourly, daily, weekly)
When a trigger fires, the agent receives:
  • The event details (error, ticket, issue, or replay)
  • Relevant metadata (labels, severity, environment)
  • Linked resources (threads, comments, related work)

Instructions

Instructions tell the agent what success looks like. Good instructions are short, concrete, and written like you would brief a teammate. Good vs vague:
  • Good: “Investigate the error, propose a fix, and report back in Slack.”
  • Vague: “Look into this and do your best.”
What great instructions include:
  • The outcome you want (e.g. identify the root cause and propose a fix)
  • Constraints (e.g. avoid risky changes, do not touch production data)
  • Where to report results (e.g. reply in Slack or comment in the ticket)
If the trigger already has rich context (like a Sentry issue or a Linear ticket), keep the instructions short and let the context do the rest.

Permissions

Each automation can override the default permission settings. Control which actions the agent can take:
  • Allow — Auto-execute without asking.
  • Require approval — Pause and ask a human first.
  • Deny — Block entirely.
See Permissions for the full model including scope limits and the resolution cascade.

Execution flow

When a trigger fires, Proliferate runs the automation through a pipeline:
1

Trigger fires

A system event happens — a ticket is created, a new error appears, or a message arrives.
2

Environment spins up

A coding agent starts in an isolated sandbox with your repo, dependencies, and secrets.
3

Context is gathered

The agent receives event details from the trigger source — error stack traces, ticket descriptions, issue metadata, and linked resources.
4

Work happens

The agent investigates, makes changes, runs tests, and prepares outputs based on the instructions.
5

Results are delivered

Outcomes show up where the work started — a Slack thread, a pull request, a ticket comment, or the web dashboard.

Example

A Sentry error fires in production. Your automation launches an agent that reads the stack trace, traces the bug to a specific function, writes a fix, runs the test suite, and opens a pull request — all without human intervention. If the automation requires approval for certain actions (like merging), the agent pauses and notifies you in Slack or the web dashboard. You approve, and the agent continues.

Next steps