AgentOutreach Autopilot · Pro plan

Let the AI run the outreach. Pick the mode that fits.

Same conservative AI brain. Same daily audit digest. Same Pro pricing. The only choice is where the runner lives: on our servers or on yours. Most people want Hosted — it's a 3-minute setup.

Start Pro free trial How Hosted works How the API works

Autopilot is included on Pro ($79/mo) and Agency ($199/mo). Free + Starter stay on the manual swipe queue.

Two modes, one engine

Both modes use the same conservative AI and produce the same daily digest. They differ in where the code runs and how much you have to operate yourself.

Recommended

Hosted Autopilot

We run it. You give us SMTP credentials and flip the switch.

Setup time: ~3 minutes
Where the runner lives: our servers
What you provide: SMTP host + user + password + From address (encrypted at rest)
What we provide: AI brain, hourly scheduler, retries, audit log, daily digest
Pause / revoke: one click in the dashboard
Cost beyond Pro subscription: $0 — AI is included

Start Pro free trial

Self-hosted Agent

You run it. We expose our API so your own AI agent can drive everything.

Setup time: ~20 minutes (or paste a prompt into Claude Code / Codex and let it set itself up)
Where the runner lives: your machine, server, or laptop
What you provide: API key, your own SMTP, your own LLM (or use Codex / Claude Code / OpenClaw / local Ollama)
What we provide: REST API, reference Python script, agent-instructions prompt, daily digest
Pause / revoke: revoke the API key
Cost beyond Pro subscription: your own AI tokens (or $0 if you run a local model)

See the API path

Same opportunities, same drafts, same conservative brain default (skip ~70% of what the scanner surfaces), same 07:11 UTC daily digest, same per-site site_profile context. The only differences are who runs the loop and where your SMTP password lives.

Mode A · Recommended for almost everyone

Hosted Autopilot

No CLI, no scripts, no cron to maintain. You connect SMTP, tick a consent box, and we run an hourly job that decides per-opportunity and sends from your own mail server.

Three-step setup

Connect SMTP at /dashboard/autopilot. Anything that speaks SMTP — Gmail (app password), Fastmail, your own domain's mail server. We send a one-time confirmation email to your claimed From address as part of verification; if it doesn't land in that inbox, the credentials aren't valid for it. Password is Fernet-encrypted at rest, decrypted only at the moment we open the SMTP connection.
Tick the consent box. Acknowledges that AgentOutreach will send emails from your inbox without per-message review and that you remain responsible for what goes out. We log the timestamp.
Flip the switch. Choose your minimum fit grade (defaults to A — strict), max-sends-per-hour cap, and send window (defaults to 13–22 UTC). Hourly cron fires at minute :17 of every hour. First run is on the next :17 — or click "Run now" to kick a manual run immediately.

What happens on each run

The runner pulls up to max-per-hour opportunities matching your minimum grade, then for each one:

Dedupe. If the same contact email already got a message earlier in this run, skip with reason.
Form-only? No email but a contact form? Skip with a FORM_FILL_REQUIRED: tag — tomorrow's digest surfaces it in a "📋 Form-only opportunities queued for you to fill manually" banner with the URL and field-value packet.
Brain decides. Claude Haiku reads your site profile + the host's page evidence + the AI-drafted pitch and returns send / edit / skip. Tuned conservative — when in doubt, skip. Target skip rate ~70%.
Send via your SMTP. Single message: From: your verified address, To: the prospect, subject + body from the draft (or the brain's edit), your per-site signature appended.
Log everything. Each action — subject sent, skip reason, form-fill packet — written to your audit log and rolled up in the daily digest.

What you see

Dashboard: /dashboard/autopilot shows the last run timestamp, action summary, and a 7-day activity table with subject lines + skip reasons.
Daily digest at 07:11 UTC: branded email to your account inbox with counts (contacted / replied / skipped / form-fills queued), per-site action breakdown, and the form-fill banner.
Manual override: the swipe UI is unchanged. Anything autopilot skipped, you can still review and send manually.

Start Pro free trial →

Mode B · For users who'd rather self-host

Self-hosted Agent

If you'd rather we never touch your SMTP password, or you want to use your own LLM (Codex, Claude Code, OpenClaw, local Ollama), or you want the runner to live inside your existing automation stack: we expose the same engine as a REST API. Bring your own brain. We bring the leads.

Pick how you want to set it up

Same API in every case. The tabs differ only in what kind of runner you point at it.

Paste this into your AI agent

The fastest self-hosted path. Copy the instruction block into a fresh Claude Code, Codex CLI, or any LLM session that can run shell commands on your machine — the agent walks you through API-key generation, SMTP setup, dry-run validation, then turns autopilot on.

Or have the agent fetch the live instructions itself: curl https://www.agentoutreach.io/static/autopilot_agent_instructions.md

You are an installation assistant for **AgentOutreach Autopilot**. Your job is to
get the autopilot agent running locally on this machine, ask the user for
anything you don't already know, and confirm before any action that modifies
their system. Follow these steps in order.

# CONTEXT — what you're setting up

AgentOutreach Autopilot is a Pro-plan API on agentoutreach.io. It lets an AI
agent (you) pull outreach opportunities, decide which to pitch, send approved
emails from the user's own SMTP, and report each action back so AgentOutreach
emails the user a daily digest.

- Docs:           https://www.agentoutreach.io/autopilot
- API base:       https://www.agentoutreach.io/api/v1/
- Reference script (your starting point): https://www.agentoutreach.io/static/autopilot.py

# STEP 1 — Working directory

Ask the user where they want autopilot installed. Suggest `~/agentoutreach/`.
Create the directory if it doesn't exist.

# STEP 2 — Get an API key (USER ACTION)

The user must generate this themselves — for security, AgentOutreach only
exposes the plaintext at the moment of creation.

Tell the user to:
1. Open https://www.agentoutreach.io/dashboard/api-keys
2. Click **Generate key**, label it something like "Riley laptop" or "Home agent"
3. Copy the `ao_live_...` string (only shown once)

Then ask them to paste it to you. Store it in memory — you'll write it to `.env`
in step 7. Do NOT echo the full key back to chat history once you have it.

# STEP 3 — Verify the key works and the plan is Pro+

Run:
```
curl -s -H "Authorization: Bearer <key>" https://www.agentoutreach.io/api/v1/me
```

- HTTP 401 → key is wrong. Ask them to re-copy.
- HTTP 402 (`plan_gated`) → user is on Free or Starter. Tell them Autopilot
  is included on Pro ($79/mo) and Agency ($199/mo), point them at
  https://www.agentoutreach.io/#pricing, and STOP.
- HTTP 200 → show the user their plan name + daily quota and continue.

# STEP 4 — Confirm a site is set up AND has a site profile

Run:
```
curl -s -H "Authorization: Bearer <key>" https://www.agentoutreach.io/api/v1/sites
```

If the response has `"sites": []`, tell the user they need to add a site first
at https://www.agentoutreach.io/dashboard/setup, then approve the AI-proposed
categories. Wait for them, then re-check. Don't continue until at least one
site has `planner_status: "approved"`.

**Also check `site_profile`** for each site. It's a 200-word structured brief
(what we do · who it's for · headline features · pricing · differentiator ·
likely objection) generated by scraping the user's homepage / about / pricing
pages. **This is your primary source of truth about the user's product** when
deciding whether to send or skip an opportunity — DO NOT rely on guesses or
the one-line `about` field.

If a site has `site_profile_generated_at: null` or an empty `site_profile`,
tell the user to:
1. Open `https://www.agentoutreach.io/dashboard/sites/<id>/edit`
2. Click "Regenerate" under the Site profile section, or
3. Paste their own 200-word brief into the textarea.

Wait until every site you'll be running against has a populated `site_profile`.

When you call `GET /api/v1/opportunities/<id>` later, the response includes
the full `site_profile` in the `site` block. Read it for every opportunity
and reference it explicitly in your decision reasoning — e.g. if the host's
page evidence doesn't connect to anything in `HEADLINE FEATURES` or
`WHO IT'S FOR`, that's a strong reason to skip.

# STEP 5 — Ask for SMTP credentials

Autopilot sends from the user's own mail server. Ask for:

- `SMTP_HOST` — usually `smtp.gmail.com`, `smtp.fastmail.com`, or their domain MX.
- `SMTP_PORT` — almost always `587` (STARTTLS). Use `465` only if they tell you so.
- `SMTP_USERNAME` — full email address in most cases.
- `SMTP_PASSWORD` — if Gmail, tell them they MUST use an **app password**
  (not their main login). Link: https://myaccount.google.com/apppasswords
- `SEND_FROM` — the From header, e.g. `Riley Chen <riley@example.com>`.
  This should match (or be a delegated alias of) `SMTP_USERNAME`.

Confirm each field before moving on. **Do not log the password to chat
history.** When you write `.env` in step 7, redact the password in any echo.

# STEP 6 — Choose the "brain"

The brain is the LLM that decides per-opportunity whether to send / edit / skip.

- If you're **Claude Code** and have `claude` on PATH: set `BRAIN=claude_code`.
- If you're **Codex CLI** and have `codex` on PATH: set `BRAIN=codex`.
- If you're a generic agent with access to the Anthropic SDK: set
  `BRAIN=anthropic`. Ask the user for `ANTHROPIC_API_KEY` (check their env
  first — many users already have one).
- If OpenAI is preferred: `BRAIN=openai` with `OPENAI_API_KEY`.

# STEP 7 — Install + configure

```bash
mkdir -p ~/agentoutreach && cd ~/agentoutreach
curl -L -o autopilot.py https://www.agentoutreach.io/static/autopilot.py
chmod 644 autopilot.py
```

Write `~/agentoutreach/.env` with mode `0600`. Include all values from steps
2, 5, 6. **Force `SEND_LIVE=0` for the first run** so nothing is actually sent
yet. Also include `MAX_PER_RUN=5` for the dry-run so it's quick.

# STEP 8 — Dry-run test

```bash
cd ~/agentoutreach && env $(grep -v '^#' .env | xargs) python3 autopilot.py
```

Read the output with the user. You should see:
- "[autopilot] authed as <email> (<plan>, quota N/day)"
- Per-opportunity lines showing the brain's decision (`send` / `skip` / `edit`)
- For `send` decisions in dry-run: lines that contain `(dry-run) would send to ...`

If everything looks right, tell the user. If the brain is skipping everything,
the issue is usually that `MIN_GRADE` is too strict (default `B+`) for what's
in their queue — lower it to `B` or `C` in `.env` and rerun.

# STEP 9 — Go live (ask first)

Ask the user explicitly: "Should I switch SEND_LIVE to 1 and start actually
sending?" Wait for an explicit yes.

If yes:
- Set `SEND_LIVE=1` in `.env`.
- Raise `MAX_PER_RUN` to something sane for their plan (Pro: 20, Agency: 100).
- Propose a cron entry — suggested default for partnership-team use:
  ```
  0 9,13,17 * * 1-5  cd ~/agentoutreach && env $(grep -v '^#' .env | xargs) python3 autopilot.py >> ~/agentoutreach/autopilot.log 2>&1
  ```
  (Three runs/day, business hours, weekdays only.) Show them the line and
  ASK before adding it to their crontab via `crontab -e`.

# DEFENSIVE PATTERNS — already baked into the reference autopilot.py, but you
# MUST keep them if you're writing your own implementation

## Per-run recipient dedupe

The brain decides each opportunity in isolation. If two opportunities surface
the same `contact_email` (one person who runs multiple sites, podcasts, or
blogs the scanner catalogued separately), each is judged independently and
each can land on "send" — producing two emails to the same person minutes
apart. The recipient sees a duplicate; the autopilot has no idea it just
emailed them.

Required defensive pattern:

```python
seen_emails: set[str] = set()
# ... inside per-opportunity loop ...
contact_email = (full.get("contact_email") or "").strip().lower()
if contact_email and contact_email in seen_emails:
    _req("POST", f"/opportunities/{full['id']}/actions",
         {"action": "skipped",
          "reason": f"duplicate contact ({contact_email}) already emailed this run"})
    actioned += 1
    continue
# ... on successful send ...
seen_emails.add(contact_email)
```

The set is scoped to this run only — across runs we rely on the API's status
transition (`new` → `contacted`) to stop us from re-emailing the same
opportunity.

## Form-only opportunities — no email, only a contact form

Some opportunities have `contact_email = ""` but `contact_form_url` set, with
`contact_form_fields` listing the form's inputs. The autopilot CAN'T submit
web forms (that would need a headless browser like Playwright). Two paths:

**Default — queue for the user to fill manually.** This is what the reference
script does. POST `skipped` with a `reason` string that starts with
`FORM_FILL_REQUIRED:` and lists the form URL plus a `label=value` packet
matching the form's fields, using suggested values from the site config and
the AI draft. The user sees these in tomorrow's digest with everything they
need to fill the form in about 30 seconds per opportunity.

```python
if not contact_email and contact_form_url:
    packet = build_form_packet(form_fields, site_ctx, draft_subject, draft_body)
    _req("POST", f"/opportunities/{full['id']}/actions", {
        "action": "skipped",
        "reason": f"FORM_FILL_REQUIRED: {contact_form_url} — {packet}",
    })
    continue
```

**Advanced — actually fill the form.** If the user wants full automation,
they can extend autopilot.py with a `submit_form()` function using
Playwright (`pip install playwright && playwright install chromium`) or
Selenium. On successful submission, POST `contacted` with `sent_subject` =
the form URL and `sent_body` = the packet of submitted values. Ask the user
before installing a browser stack — most users prefer the default queue path.

## Don't send when the brain says "send" but there's no email

If the brain returns `action: send` on a form-only opp (it shouldn't, but
guard anyway), fall through to the form-fill path or skip with reason
`"brain decided 'send' but no contact_email — visit the page to submit manually"`.

# STEP 10 — Confirm and hand off

Tell the user:
1. Autopilot is now running on schedule.
2. Tomorrow at **07:11 UTC** they'll receive a digest email summarising what
   was sent / skipped / replied in the last 24h.
3. They can revoke the API key anytime at
   https://www.agentoutreach.io/dashboard/api-keys.
4. To pause autopilot temporarily, comment out the cron line.
5. To re-tune the agent, edit `MIN_GRADE`, `MAX_PER_RUN`, or `AGENT_AUTO_EDIT`
   in `.env`.

Done.

# Anticipated user questions — be ready

**Q: How much does the AI brain cost?**
At ~$0.005 per decision on Anthropic Haiku, 20 leads/day is ~$3/month on top
of the Pro subscription. Codex CLI on the ChatGPT plan is effectively $0
incremental. Local-model brains (OpenClaw, Ollama) are $0.

**Q: What if it makes a bad decision?**
Every action is logged in the daily digest with the actual subject sent. The
user can revoke the API key from `/dashboard/api-keys` instantly, and review
the digest to see anything that went out.

**Q: Will it spam?**
Daily quota caps it at 100/day (Pro) or 500/day (Agency). Skip-reasons train
the per-site filter — repeated rejections deprioritise matching domains on
the next scan.

**Q: Can I run it forever in dry-run?**
Yes. With `SEND_LIVE=0` the agent will mark its intent (or skip) but never
actually send. Some users prefer this as an indefinite "AI says go, I send
manually" workflow.

**Q: Can I have it edit the drafts before sending?**
`AGENT_AUTO_EDIT=1` (default) lets the brain return `action: edit` and supply
a rewritten subject + body. Set `AGENT_AUTO_EDIT=0` to force send-as-is or
skip with no editing in between.

Plain Python script (cron-friendly)

One file, no framework. Run from cron or systemd.

Generate an API key
Download autopilot.py
Set env vars and run:

export AGENTOUTREACH_API_KEY="ao_live_..."
export ANTHROPIC_API_KEY="sk-ant-..."           # the brain (or BRAIN=openai/codex/claude_code)
export SMTP_HOST="smtp.gmail.com"
export SMTP_PORT="587"
export SMTP_USERNAME="riley@yourdomain.com"
export SMTP_PASSWORD="..."                      # app password if Gmail
export SEND_FROM="Riley <riley@yourdomain.com>"
export SEND_LIVE="0"                            # 1 to actually send

python3 autopilot.py

Defaults to dry-run so you can audit before letting it send.

Codex CLI

Use Codex CLI itself as the brain. ChatGPT-plan covers the cost.

export AGENTOUTREACH_API_KEY="ao_live_..."
export BRAIN="codex"                            # autopilot.py shells out to `codex exec`
export SMTP_HOST="..."
# ... SMTP creds same as Python tab ...

# Schedule via codex's own scheduler or system cron.

Claude Code (CLI)

Use Claude Code as the brain. Schedule via system cron or Claude Code's /loop.

export AGENTOUTREACH_API_KEY="ao_live_..."
export BRAIN="claude_code"                      # shells out to `claude -p`
export CLAUDE_CODE_OAUTH_TOKEN="..."            # for unattended runs
export SMTP_HOST="..."
# ... SMTP creds same as Python tab ...

OpenClaw

Use a local-LLM brain via OpenClaw — zero per-lead AI cost, ideal for Agency-plan volume.

# OpenClaw recipe pattern:
# 1. GET https://www.agentoutreach.io/api/v1/sites/<id>/opportunities (Bearer ao_live_...)
# 2. Per opp: local-LLM decide → SMTP send → POST /actions
# 3. Schedule daily.

API reference

Authenticate with Authorization: Bearer ao_live_…. Base URL: https://www.agentoutreach.io/api/v1/.

GET /me: Who am I + plan + daily quota. Health check.
GET /sites: List your sites, including site_profile for each.
GET /sites/<id>: One site's full detail (label, URL, sender, profile).
GET /sites/<id>/opportunities: List opportunities. Query: status (default new,discovered), min_grade (B/B+/A-/A/A+), min_score, limit (max 200).
GET /opportunities/<id>: Full detail: evidence, draft, contact email or form URL + fields, ready-to-use mailto, site context including site_profile.
POST /opportunities/<id>/actions: Record the action. JSON: {action: "contacted"|"skipped"|"replied"|"booked"|"declined", reason?, sent_subject?, sent_body?, reply_summary?}. Skip reasons train the per-site filter.

Start Pro free trial

What both modes share

Whichever mode you pick, the experience downstream is identical.

Conservative AI brain

The decide step is tuned around the asymmetry of error: a bad send is permanent (real email goes to a real person), a skipped send is recoverable (the same prospect will surface again on next refresh). The brain leans hard toward skip — target rate ~70%. If 100% accuracy matters, keep autopilot off and review in the swipe UI.

Daily digest at 07:11 UTC

One branded email per day to the inbox you registered with. Counts table at the top, per-site activity breakdown, "form-fills queued for you" banner if any opportunities couldn't be auto-sent because they only have a contact form.

Site profile context

The brain reads a 200-word structured profile of your site (auto-generated by scraping your homepage + about + pricing pages) as its source of truth about your product. No more "made-up feature" drafts — the brain refuses to claim capabilities the profile doesn't list.

Send from your inbox

Both modes send from your SMTP. Your domain reputation stays yours; replies come back to you directly. The difference is who decrypts the password — in Hosted mode, our server does at send time (Fernet at rest); in Self-hosted mode, your script does.

FAQ

Do you send emails from your servers?: No — neither mode sends from us. Hosted opens an SMTP connection to your mail server using credentials you provided. Self-hosted never sees the password at all. Either way, the email originates from your domain.
What's the rate limit?: Both modes respect your plan's daily quota — Pro is 100/day, Agency is 500/day. Pulls (reads) are unlimited.
Can I run both modes at once?: Technically yes, but you'll race for the same opportunities. Pick one. If you want to switch from Self-hosted to Hosted, just connect SMTP at /dashboard/autopilot and disable your local script — the API keys you've generated keep working but Hosted will start picking up opps first.
What if autopilot sends a bad email?: Worst case: a handful of weak pitches go out before the daily digest reaches you. Revoke instantly via /dashboard/autopilot (Hosted) or /dashboard/api-keys (Self-hosted). Every send is logged with subject + body so you can audit what went out.
Why is the default minimum grade A?: Without a human reviewer, the brain has to be stricter than the scanner. A means only the top ~10% of opportunities the scanner surfaces are even considered for send — and the brain still skips most of those. Send fewer, better.

Start Pro free trial →