Skip to content

Examples

Jump to bottom
Daniel Baldwin edited this page Sep 3, 2026 · 5 revisions

Examples

A cookbook of complete, copy-pasteable config.yaml snippets — one per scenario. Each is minimal but valid on its own; combine sections under one top-level integrations:/agents: as needed. See Configuration for the full field reference and Workflows for the steps:/if:/background: mechanics used below.

GitHub PR autopilot: fix failing checks, resolve conflicts, respond to reviews

The core autopilot loop — a PR gets CI failures fixed, conflicts resolved, and review feedback addressed, all pushed as you.

integrations:
  - type: github
    name: github
    enabled: true
    app:
      app_id: 123456
      private_key_path: ~/.config/conductor/github-app.pem
      webhook_secret: ${GH_WEBHOOK_SECRET}
      verify_signature: false
    webhook:
      smee_url: ${GH_SMEE_URL}
    defaults:
      me: { logins: [octocat] }
      actions:
        merge_conflict:
          type: agent
          agent: fixer
          prompt: "This PR conflicts with base {{.base}}. Merge/rebase, resolve, build, commit, push."
        failing_checks:
          type: agent
          agent: fixer
          flaky_rerun: { enabled: true, max: 1 }
          prompt: "Checks are failing on {{.repo}}#{{.pr}}. Diagnose with `gh run view --log-failed`, fix, verify, commit, push."
        changes_requested:
          type: agent
          agent: fixer
          rerequest_review: true
          prompt: "A reviewer requested changes on {{.repo}}#{{.pr}}. Address each point, commit, push, reply to threads."
        new_comment:
          type: agent
          agent: fixer
          ignore_users: ["github-actions[bot]"]
          prompt: "New comment on {{.repo}}#{{.pr}} by {{.author}}: {{.comment_body}}. Act if actionable, commit, push, reply."
    rules:
      - match: { repos: ["octocat/*"] }

agents:
  fixer: { provider: claude, workspace: worktree, archive_when_done: true }

Review hand-off to a Slack DM

Route a background: true review step to your phone instead of paseo's own UI — useful when you want to approve/revise/discard from Slack.

handoffs:
  phone:
    slack:
      to: dm
      user: ${SLACK_USER_ID}       # a Slack user id (Copy member ID), not a GitHub handle
      bot_token: ${SLACK_BOT_TOKEN}
    default: true

integrations:
  - type: github
    name: github
    app: { app_id: 123456, private_key_path: ~/.config/conductor/github-app.pem, webhook_secret: ${GH_WEBHOOK_SECRET} }
    webhook: { smee_url: ${GH_SMEE_URL} }
    defaults:
      me: { logins: [octocat] }
      actions:
        changes_requested:
          steps:
            - id: draft
              type: agent
              agent: fixer
              checkout: branch-off
              prompt: "Address the review feedback on {{.repo}}#{{.pr}} and prepare the fix."
            - id: review
              background: true
              handoff: phone
              type: agent
              agent: fixer
              prompt: "Present the fix for {{.repo}}#{{.pr}} for approval before pushing."
    rules:
      - match: { repos: ["octocat/*"] }

agents:
  fixer: { provider: claude, workspace: worktree }

Capturing the DM reply also requires a running slack control-plane integration (Socket Mode) — see the Slack control plane example below and Integration-Slack.

Cron: nightly job

A time-based trigger with no external event — here, a nightly cache clean and a periodic rate-limit check.

integrations:
  - type: cron
    name: chores
    schedules:
      - name: rate-limit-check
        every: 6h
        action: { type: command, backend: local, command: ["gh", "api", "rate_limit"] }
      - name: nightly-clean
        cron: "0 4 * * *"          # 4am daily
        run_on_start: false
        action:
          type: command
          backend: local
          workdir: ~/Projects/myrepo
          command: ["make", "clean"]

Generic webhook → agent

Any service that can POST JSON becomes a trigger with no bespoke integration code — here, a CloudWatch alarm dispatches an investigating agent.

integrations:
  - type: webhook
    name: inbound
    listen: ":8099"
    sources:
      - name: cloudwatch
        path: /hooks/cloudwatch
        sign: { header: X-Amz-Signature, secret: ${CW_SECRET}, scheme: hex }
        match: '{{if eq .body.detail.state "ALARM"}}true{{end}}'
        title: "{{.body.detail.alarmName}} → {{.body.detail.state}}"
        dedup: "{{.body.detail.alarmName}}-{{.body.time}}"
        repo: octocat/infra
        actions:
          type: agent
          agent: fixer
          prompt: "CloudWatch alarm {{.body.detail.alarmName}} fired — investigate {{.repo}}."

agents:
  fixer: { provider: claude, workspace: worktree }

Sentry alert → triage

A production error becomes an agent that root-causes it against the affected repo.

integrations:
  - type: sentry
    name: prod
    listen: ":8098"
    client_secret: ${SENTRY_CLIENT_SECRET}
    rules:
      - match: { projects: [myapp], levels: [error, fatal], environments: [production] }
        repo: octocat/myapp
        actions:
          type: agent
          agent: fixer
          checkout: branch-off
          prompt: "Sentry {{.sentry.short_id}}: {{.sentry.title}} ({{.sentry.culprit}}). Root-cause in {{.repo}} — see {{.url}}. Open a draft PR or a findings issue."

agents:
  fixer: { provider: claude, workspace: worktree }

RSS feed → impact assessment

Poll an upstream changelog and have a cheap model assess whether it affects your repo, filing a heads-up issue when it does.

integrations:
  - type: rss
    name: upstream
    feeds:
      - name: canvas-changelog
        url: https://example.instructure.com/doc/api/file.changelog.html
        interval: 1h
        match: "deprecat|breaking|remov"
        repo: octocat/myapp
        actions:
          type: agent
          agent: planner
          checkout: none
          prompt: "Upstream changelog: {{.item.title}} ({{.url}}). Does this affect {{.repo}}? File a heads-up issue if so."

agents:
  planner: { provider: claude, model: claude-haiku-4-5, workspace: local }

PagerDuty page → triage

An incident page starts triage against the affected repo instead of waiting for a human to open a terminal.

integrations:
  - type: pagerduty
    name: oncall
    listen: ":8097"
    signing_secret: ${PAGERDUTY_SIGNING_SECRET}
    rules:
      - match: { event_types: [incident.triggered, incident.escalated], urgencies: [high], services: [myapp-api] }
        repo: octocat/myapp
        actions:
          type: agent
          agent: fixer
          checkout: branch-off
          prompt: "PagerDuty {{.pagerduty.title}} ({{.pagerduty.priority}}/{{.pagerduty.urgency}}) on {{.pagerduty.service}} — {{.url}}. Start triage in {{.repo}}: find the likely cause, propose a mitigation."

agents:
  fixer: { provider: claude, workspace: worktree }

Slack mention control plane

An @-mention dispatches an agent and reacts to acknowledge/complete/fail — a conversational front end with no public URL (Socket Mode).

integrations:
  - type: slack
    name: ops
    app_token: ${SLACK_APP_TOKEN}
    bot_token: ${SLACK_BOT_TOKEN}
    triggers:
      - on: app_mention
        ack: { react: eyes }
        on_done: { react: white_check_mark }
        on_fail: { react: x, say: "couldn't finish: check the logs" }
        actions:
          type: agent
          agent: fixer
          checkout: none
          prompt: "Slack request from <@{{.slack.user}}>: {{.slack.text}}. Do it and report back."

agents:
  fixer: { provider: claude, workspace: worktree }

Multi-step workflow with a background review hand-off

Assess an issue with a cheap model, implement it with a stronger one only if there's enough context, then hand the result to you for review before it's finalized.

integrations:
  - type: github
    name: github
    app: { app_id: 123456, private_key_path: ~/.config/conductor/github-app.pem, webhook_secret: ${GH_WEBHOOK_SECRET} }
    webhook: { smee_url: ${GH_SMEE_URL} }
    defaults:
      me: { logins: [octocat] }
      actions:
        issue_matched:
          labels_any: ["Ready"]
          steps:
            - id: evaluate
              type: agent
              agent: planner
              checkout: none
              output_schema:
                type: object
                properties: { has_context: { type: boolean }, summary: { type: string } }
              prompt: "Is there enough detail to implement {{.repo}}#{{.issue}}? Return has_context + summary."
            - id: work
              if: "steps.evaluate.outputs.has_context == true"
              type: agent
              agent: fixer
              checkout: branch-off
              prompt: "Implement {{.repo}}#{{.issue}} — {{.steps.evaluate.outputs.summary}}. Open a draft PR."
            - id: review
              if: "steps.evaluate.outputs.has_context == true"
              background: true
              type: agent
              agent: fixer
              prompt: "Present the draft PR for {{.repo}}#{{.issue}} for approval."
            - id: ask
              if: "steps.evaluate.outputs.has_context == false"
              type: command
              command: ["gh","issue","comment","{{.repo}}#{{.issue}}","--body","Please add repro steps and scope."]
              env: { GH_TOKEN: "{{.gh_token}}" }
    rules:
      - match: { repos: ["octocat/*"] }

agents:
  planner: { provider: claude, model: claude-haiku-4-5, workspace: local }
  fixer: { provider: claude, workspace: worktree }

With no handoffs: block configured, the review step's approve/revise/discard loop runs in paseo itself; add a handoffs: entry (web link, Slack, or Discord — see Hand-offs) to route it elsewhere.

Two-controller setup

Run most agents on the built-in paseo runtime, but route one profile to a gemini CLI over ACP and another through opencode's own HTTP API — each agent picks its controller explicitly.

controllers:
  gemini-review:              # agent: + no transport → ACP over stdio
    agent: gemini
  opencode:
    type: opencode             # opencode's native HTTP API (opencode serve)

agents:
  reviewer:
    controller: gemini-review  # runs gemini over ACP — no provider needed
  planner:
    controller: opencode       # runs via opencode, which routes to this provider/model
    provider: anthropic
    model: claude-sonnet-4-5
  fixer:
    provider: claude           # no controller: → the built-in paseo runtime runs claude
    workspace: worktree

integrations:
  - type: github
    name: github
    app: { app_id: 123456, private_key_path: ~/.config/conductor/github-app.pem, webhook_secret: ${GH_WEBHOOK_SECRET} }
    webhook: { smee_url: ${GH_SMEE_URL} }
    defaults:
      me: { logins: [octocat] }
      actions:
        review_requested:
          type: agent
          agent: reviewer
          checkout: none
          prompt: "Review {{.repo}}#{{.pr}} and post your findings."
        failing_checks:
          type: agent
          agent: fixer
          prompt: "Checks failing on {{.repo}}#{{.pr}} — diagnose, fix, push."
    rules:
      - match: { repos: ["octocat/*"] }

See Controllers for the full resolution order and runtime matrix.

Home

Setup

The model

Connectors

Operations

Clone this wiki locally