# How we keep our content from going stale

The content-refresh agent we run on Kortix — a weekly agent that finds decaying marketing and blog pages via Search Console, refreshes the copy, stats, and internal links, and opens a PR for review.

Canonical page: https://openchatly.com/use-cases/content-refresh

Most published content doesn't die all at once. A comparison page that used to
rank on page one slides to page two as a competitor updates their pricing. A
blog post cites a stat from two years ago and a reader notices. A guide links
to a feature we renamed six months back. None of it is broken enough to
trigger an alert, so it just sits there, quietly losing impressions, until
someone happens to look.

We run a content-refresh agent on Kortix that watches for that decay every
week and does something about it. It reads Search Console for pages losing
impressions and clicks, cross-references them against our content repo,
refreshes the copy, the stats, and the internal links, and opens a PR. It
never publishes anything itself — a human reviews and merges.

- **Team:** Kortix
- **Runs on:** Weekly cron
- **Connected systems:** Google Search Console · GitHub
- **Mode:** Reusable session · PR only, never publishes

## The problem

Nobody schedules time to re-read a two-year-old blog post. Content gets
written once, published, and then left alone unless it's actively broken.
Meanwhile the world underneath it keeps moving: prices change, product names
change, competitors update their own pages, and search intent drifts. Search
Console sees all of that as a slow decline in impressions and clicks per page,
but nobody is watching that report on a schedule, and even when someone is,
"this page is declining" doesn't tell you what to fix.

Doing it manually doesn't scale either. A content team can audit a handful of
pages a quarter if they're disciplined about it, but a site with hundreds of
pages generates decay faster than any manual process can keep up with, and the
same handful of high-traffic pages get all the attention while the long tail
quietly rots.

## What we built

On Kortix, a weekly cron re-prompts a **persistent session** — the same agent,
picking up where last week left off. It pulls the pages losing the most
impressions and clicks from Search Console, cross-references them against our
content repo, and rotates through them so the same three pages don't get all
the attention while the rest decay untouched. For each page it picks that
week, it refreshes the copy that's gone stale, updates any numbers or stats
that have aged out, fixes internal links that point at renamed or superseded
pages, and opens one PR per run. It never pushes to the live branch and never
merges its own work.

## 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 refresh skill and the weekly trigger, and
opens a change request for you to review. Prefer clicks? Choose **Use this
template** instead.

**Setup prompt**

```
Set up a weekly content refresh agent in this workspace.

1. Create the agent agents/content-refresh.md. Its job is to keep the marketing and blog pages in owner/repo from decaying in search. It may use the Google Search Console connector and a GH_TOKEN secret for GitHub.

2. Create the skill skills/content-decay-refresh/SKILL.md with these rules:
   - Compare impressions and clicks per page under apps/web/content for the last 28 days with the 28 days before. Rank pages by decay, weighted by traffic.
   - Read memory/content-refresh-log.md first. A page refreshed in the last two weeks drops in priority. A page never refreshed moves up.
   - Take the top 3 to 5 pages as the week's batch.
   - Refresh only dated copy, aged-out stats and internal links to renamed or retired pages. If no current figure exists, soften the claim.
   - Edit only files under apps/web/content, on a new branch. Open one pull request per run. Never merge it.
   - If nothing is stale enough, update the ledger and stop without a pull request.

3. Add a cron trigger weekly-content-refresh to kortix.yaml. It runs the content-refresh agent every Monday at 09:00 with the prompt "Load the content-decay-refresh skill and run one complete refresh pass for sc-domain:example.com."

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

Open **Connectors** in your workspace and connect Google Search Console.
Connector credentials are brokered server-side and never enter the agent's
machine. Add a GitHub token as the `GH_TOKEN` secret so the agent can open the
pull request.

- **Google Search Console** (Required):
Reads impressions and clicks to rank decaying pages.
- **GitHub** (Required):
Refreshes stale pages on a branch and opens one PR.

### Run it once with this prompt

Merge the change request, then start a session with the **content-refresh** agent
and send this prompt. Read the pull request before you let the
schedule take over.

**Prompt**

```
Run one content refresh pass for sc-domain:example.com.

1. Read memory/content-refresh-log.md and check for an open content refresh pull request.
2. Pull impressions and clicks per page under apps/web/content for the last 28 days and the 28 days before. Rank pages by decay, weighted by traffic.
3. Move pages refreshed in the last two weeks down the list. Take the top 3 to 5 as this week's batch.
4. On a new branch, update dated copy, aged-out stats and internal links to renamed pages. Change nothing else.
5. Open one pull request in owner/repo with the decay signal and the change for each page. Do not merge it.
6. Add what you refreshed to the ledger.
```

### Let the weekly schedule take over

The change request added this trigger to `kortix.yaml`. From now on the agent
runs every Monday at 09:00, each run in a new session on its own cloud
computer. The ledger in memory carries the rotation from one week to the next.
To change the time, edit the cron line, or open **Triggers** in the workspace.

**kortix.yaml**

```yaml
triggers:
  - slug: weekly-content-refresh
    name: Weekly content refresh
    on:
      cron: "0 0 9 * * 1"
    run:
      agent: content-refresh
      prompt: Load the content-decay-refresh skill and run one complete refresh pass for sc-domain:example.com.
```

### Open a pull request, never publish

The agent edits only files under the content path, on its own branch. It
opens one pull request per run and stops. A person reviews the diff and merges
it. Search Console access is read-only, so the agent cannot change anything
there.

### Review the pull request

Each run ends with one pull request and a ledger entry. This is what a run
looks like in the session:

> **Weekly content refresh · Mon 09:00**
>
> Prompt: Load the content-decay-refresh skill and run one complete refresh pass for sc-domain:example.com.
>
> Refreshed **4** pages from **27** decaying candidates. Updated **9**
> aged-out stats and repointed **6** internal links to renamed pages. The pull
> request is open for review, and **2** pages move up the ledger for next week.

> **The pattern**
> A weekly cron re-prompts a **reusable session** that reads decay signals
> from Search Console, rotates coverage using its own **ledger**, and edits
> content on an isolated branch. The only output is a PR — never a push to the
> live branch.

## Make it do more

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

**Fix titles that lose clicks**

```
For each page in the batch, also rewrite the meta title and description when clicks fell faster than impressions.
```

**Flag pages that compete**

```
When two pages rank for the same query in Search Console, list them in the pull request body as candidates to merge, and edit neither one.
```

**Monthly decay table**

```
On the first Monday of each month, add a table to the pull request body with the 10 pages that lost the most clicks and whether each one was refreshed.
```

## Guardrails

The agent edits marketing and blog copy, so what it can do without a human is
tightly bounded:

- **PR only, never publish.** The agent opens a pull request and stops. It
  never pushes to the live branch and never merges its own work.
- **Isolation.** Every run happens in its own sandbox, on its own branch. The
  live content branch is never touched directly.
- **Scoped secrets.** The `GH_TOKEN` used by the `gh` CLI is encrypted in the
  Secrets Manager and injected into the sandbox at runtime, scoped to the agents you grant them to.
- **Read-only search data.** Search Console access is read-only; the agent
  can see decay signals but cannot change anything in Search Console itself.
- **Everything is code.** The rotation ledger, the refresh rules, and the
  agent's permissions are files in the repo, changed through a reviewed
  **change request** rather than a dashboard setting.

## The outcome

- **Every week:** A new batch of decaying pages picked up and refreshed
- **PR only:** Nothing published without a human review
- **0 repeats:** Ledger-driven rotation so coverage doesn't fixate on the same pages

Pages that used to decay silently for months now get caught within weeks of
losing traction, refreshed on a rotation that reaches the whole site instead
of just the pages someone happened to remember. The agent finds the decay and
does the editing; the team still decides what goes live.
