# How we monitor competitors

A daily agent that checks competitor sites, changelogs, and pricing pages, diffs them against the last run, and posts a short summary of what changed to Slack.

Canonical page: https://openchatly.com/use-cases/competitor-watch

Competitors ship changes quietly. A pricing tier moves, a feature lands in the
changelog, a landing page gets rewritten — and unless someone happens to check
that week, the team finds out late. Manually visiting a dozen sites every morning
is the kind of task that gets done for a while and then quietly stops.

We watch our market with an agent that runs every day on Kortix. It checks
competitor sites, changelogs, and pricing pages, diffs them against the last run,
and posts a short summary of what actually changed to a Slack channel.

- **Team:** Kortix
- **Control surface:** Slack
- **Connected systems:** The web · Slack
- **Mode:** Daily cron · diff against last run

## The problem

Keeping up with competitors is a standing task with no natural owner. The
information is public, but it's spread across pages that change on no schedule,
and most days nothing moves — so a person checking manually spends most of their
time confirming that nothing happened.

The workarounds thin out. A page-change alerting tool fires on every edit,
including cosmetic ones, and buries the real signal in noise. A shared doc of
"things to check" depends on someone remembering to check it. The task needs to
run daily, compare against what it saw last time, and only surface what's worth
reading.

## What we built

A cron trigger runs an agent every day. Each run spawns an isolated session that
fetches the competitor pages we track, compares them against the previous run's
snapshot, and writes a short summary of what changed to Slack. Cosmetic edits are
filtered out; pricing moves, new features, and messaging changes are called out.

## How it works

### Copy the setup prompt into a new session

Open your Kortix workspace, start a new session, paste this prompt and send it.
The agent writes the agent file, the competitor-diff skill and the daily
trigger, and opens a change request for you to review. Prefer clicks? Choose
**Use this template** instead.

**Setup prompt**

```
Set up a daily competitor watch agent in this workspace.

1. Create the agent agents/competitor-watch.md. Its job is to check competitor pages for real changes and post a daily summary. It may fetch public web pages and use the Slack connector.

2. Create the skill skills/competitor-diff/SKILL.md with these rules:
   - Track only the pages on the watch list I give you, one competitor, page and URL per line.
   - Store a normalized snapshot of each page in memory/competitor-watch-log.md and diff each run against it.
   - Strip navigation, footers, timestamps and whitespace before you compare.
   - Report price and plan changes, new changelog entries and rewritten headlines. Drop typo fixes, layout changes and reordering.
   - Post one summary to #growth per run, or one short line when nothing changed. Never log in to a site or write anywhere else.

3. Add a cron trigger daily-competitor-watch to kortix.yaml. It runs the competitor-watch agent every day at 06:00 with the prompt "Load the competitor-diff skill and run today's competitor-watch sweep."

4. Tell me which of these connectors are not connected yet.

5. Open a change request with all of it. Do not merge it.
```

### Connect your tools

The agent reads public pages with its built-in fetch, so the watch list needs
no connector. Open **Connectors** in your workspace and connect Slack for the
summary. Credentials are brokered server-side and never enter the
agent's machine.

- **Slack** (Required):
Posts the daily summary of real competitor changes.
- **Notion** (Optional):
Stores the competitor research you want to keep.

### Run it once with this prompt

Merge the change request, then start a session with the **competitor-watch**
agent and send this prompt. The first run only stores snapshots, so run it a
second time to see a diff before you let the schedule take over.

**Prompt**

```
Run one competitor-watch sweep.

1. Read memory/competitor-watch-log.md for the last snapshot of each tracked page.
2. Fetch every page on the watch list and normalize it.
3. Diff each page against its snapshot and drop cosmetic edits.
4. Post a short summary of real changes to #growth: competitor, what changed, and the page. If nothing changed, post one line.
5. Save today's snapshots to the ledger.
```

### Let the daily schedule take over

The change request added this trigger to `kortix.yaml`. From now on the agent
runs every day at 06:00 and picks up from its ledger in `memory/`. To change the time, edit the cron line, or open
**Triggers** in the workspace.

**kortix.yaml**

```yaml
triggers:
  - slug: daily-competitor-watch
    name: Daily competitor watch
    on:
      cron: "0 0 6 * * *"
    run:
      agent: competitor-watch
      prompt: Load the competitor-diff skill and run today's competitor-watch sweep.
```

### Read public pages only

The agent sends plain GET requests to public pages and writes only to one
Slack channel. It never logs in to a site and has no access to internal
systems. The watch list changes only through a reviewed change request.

### Read the summary

Each run ends with one message in the channel. This is what a run looks like
in the session:

> **Daily competitor watch · 06:00**
>
> Prompt: Load the competitor-diff skill and run today's competitor-watch sweep.
>
> Checked **12** tracked pages and found **2** real changes. One competitor
> raised its team plan by **$5** per seat, and another shipped **1** new
> changelog entry for an API feature. The other **10** pages had no meaningful
> change.

> **The pattern**
> Run the check on a **cron trigger**, keep the watch list and last-run snapshot in
> **skills** and **memory**, give the agent scoped **connectors** to the web and
> Slack, and let each run diff and report. The team reads a summary instead of
> browsing.

## Make it do more

Once it works, paste any of these into the same session.

**Watch review pages**

```
Also track each competitor public review page, and report new reviews that mention pricing or a missing feature.
```

**Monthly battlecard update**

```
On the first of each month, draft updates to our battlecards from the changes you reported, and open a change request for review.
```

**Tell sales about price moves**

```
When a competitor changes a price, post the change to #sales as well as #growth.
```

## Guardrails

Even a read-only agent runs with the same controls as the rest of the platform:

- **Isolation.** Each run executes in its own isolated sandbox, and only the Slack
  summary it's explicitly allowed to send is written back out.
- **Scoped secrets.** Any credential the agent uses is encrypted in the secrets
  manager and injected into the sandbox at runtime, scoped to the agents you grant them to or
  the logs.
- **Human approval gates.** The agent's only external action is posting a summary;
  anything beyond that scope would require a person to approve.
- **Everything is code.** The watch list, the pages to check, and the definition
  of a meaningful change are files in the repo — versioned and changed through a
  reviewed **change request** rather than a dashboard setting.

## The outcome

- **Daily:** The market is checked without anyone remembering to
- **Diff-only:** Cosmetic edits filtered out, real changes surfaced
- **One message:** A summary instead of a dozen tabs

The team learns about a competitor's pricing move or feature launch the morning
after it happens rather than whenever someone next looks. Because each run diffs
against the last, the channel stays quiet on quiet days and speaks up only when
something actually changed.
