Your subscriptions are quietly getting more expensive. Netflix bumps you from $15.49 to $17.99. Spotify creeps from $9.99 to $11.99. Adobe goes from $54.99 to $59.99. None of them send a “hey, we raised your price” email — the increase is buried in the billing receipt you never read. Multiply this across millions of consumers, and you get Pap!'s insight: there's $70B+ sitting in people's inboxes that they don't know about.

The challenge for companies like Pap! is that scanning a user's inbox with an AI agent is expensive. The agent has to search Gmail for billing emails, read each one, regex out dollar amounts, group by sender, compare month-over-month, and flag increases. That's 20+ sequential tool calls, ~50 seconds, and ~16K tokens — per user. Every time.

But here's the thing: the script is the same for every user. The only thing that changes is the data. This is exactly the kind of problem that Airstore and Raysurfer solve together.

Airstore: Gmail as a filesystem

Airstore turns integrations into a mountable filesystem. You connect Gmail, define a smart folder with a natural language query like “billing and subscription receipt emails from the last year”, and Airstore materializes matching emails as files on your local machine:

terminal

$ airstore mount ~/airstore
$ ls ~/airstore/gmail/billing-receipts/

2025-01_Spotify_billing.md
2025-02_Adobe_billing.md
2025-03_Netflix_billing.md
2025-06_Netflix_billing.md
2025-07_Spotify_billing.md
2025-08_Adobe_billing.md

No OAuth token juggling, no Gmail API pagination, no MIME parsing. Your agent just reads files. Each email is a clean markdown file with the sender, date, subject, and body.

Raysurfer: cache the script, not the data

Now your agent has the data as files. It still needs to do something with them. Without caching, it regenerates the detection logic from scratch every time — reading each file, figuring out how to extract amounts, grouping by sender, comparing prices. That's where Raysurfer comes in.

The first time your agent runs the subscription audit, Raysurfer caches the script:

agent.py

from raysurfer import AsyncRaySurfer

async with AsyncRaySurfer() as client:
    result = await client.search(
        "Scan billing emails for subscription price increases"
    )
    if result.matches:
        # Cache hit — execute the cached script directly
        script = result.matches[0].code_block.source
        exec(script)

Every subsequent user gets a cache hit. The agent doesn't regenerate 20 tool calls — it pulls a verified, parameterized Python script and runs it against the Airstore-mounted files in one shot.

The cached script

Here's what Raysurfer caches and resurfaces — a single function that reads Airstore-mounted billing emails, regexes out dollar amounts, and flags increases:

detect_subscription_creep.pycache hit

import re
from pathlib import Path

def detect_subscription_creep(
    billing_folder: Path,
    threshold_pct: float = 0.0,
) -> list[dict]:
    amounts: dict[str, list] = {}
    for email_file in sorted(billing_folder.glob("*.md")):
        content = email_file.read_text()
        service = email_file.stem.split("_")[1]
        match = re.search(r"\$(\d+\.?\d*)", content)
        if match:
            amounts.setdefault(service, []).append(
                (float(match.group(1)), email_file.stem.split("_")[0])
            )
    increases = []
    for service, history in amounts.items():
        history.sort(key=lambda x: x[1])
        if history[-1][0] > history[0][0] * (1 + threshold_pct):
            increases.append({
                "service": service,
                "old": history[0][0],
                "new": history[-1][0],
                "annual_impact": (history[-1][0] - history[0][0]) * 12
            })
    return increases

Notice what's parameterized: the billing_folder path and the threshold_pct. No hardcoded values. The script works for any user's Airstore-mounted inbox.

We ran it

We built a working demo that simulates Airstore-mounted billing emails and uses the real Raysurfer API to cache and retrieve the detection script. Here's the actual output:

demo output

[2] Searching Raysurfer for cached detection script...
    Cache HIT! Found: detect_subscription_creep.py
    Score: 0.610
    Search time: 0.087s

[3] Running detection against Airstore billing emails...
    Execution time: 0.001s

    Netflix:  $15.49 -> $17.99  (+$2.50/mo, $30.00/yr)
    Spotify:  $9.99  -> $11.99  (+$2.00/mo, $24.00/yr)
    Adobe:    $54.99 -> $59.99  (+$5.00/mo, $60.00/yr)

    TOTAL: 3 subscriptions increased
    TOTAL annual impact: $114.00

0.087 seconds to retrieve the cached script. 0.001 seconds to execute it. $114 found. Compare that to an agent grinding through 20+ tool calls for 50 seconds.

Why this matters for refund automation

Companies like Pap! are building a service where you sign up once, do nothing, and earn money from refunds you're entitled to — price drops, flight delays, class-action settlements. They're already doing retail price drops and flights. Subscription creep is the natural next category.

The pattern is always the same: scan emails, extract structured data, compare against a source of truth, file a claim. The data changes per user. The script doesn't. Airstore handles the data layer (Gmail → files). Raysurfer handles the code layer (cache → execute). Together, adding a new refund category is zero marginal cost per user.

Try it yourself

The demo is open source. Clone it, set a RAYSURFER_API_KEY, and run it:

terminal

$ pip install raysurfer
$ python demo_airstore_raysurfer.py

First run uploads the script (cache miss). Second run? Instant cache hit. Every run after that is free.

If you're building AI agents that process email, documents, or any repeating workflow — let's talk.