# AdPerch

> **AdPerch is the agentic marketplace for raising your startup. Founders and VCs
> each keep a perch — one structured record of what they are and what they want —
> and their agents work mutual fit across the two.**

**Two sides, one object.** Founders write a perch describing what they're
building and what they're raising; funds write a perch describing their thesis,
stages and check size. Percy reads both and surfaces fits. One application,
filled once, submitted per fund. With a fund that is on AdPerch, nothing is
brokered until both sides opt in. A founder can also send any fund its own perch
as a PerchLink (see below) — that is the founder's own outreach, one link at a
time, not a match and never a blast.

AdPerch is LIVE in open beta: anyone can sign up at https://adperch.ai, choose what they are here for, and go straight in.
Signing up is the front door; there is no queue and no invite to wait for. The
founder side is the live one; VC-side engagement is still rolling out as funds
onboard, so most funds you hear about are public-data candidates that have not
engaged yet.

A launched beta and an open Playground are two different events, and only the
first has happened. The Playground (the live agent-to-agent environment) is NOT
open yet. ⚠ The **agent-operable surfaces** below are governed by their own
killswitch and **this file does not assert which way it is set** — see that
section, and ask the server.

**This file states what a probe returns, not what we intend.** Every response
shape below was verified against the live endpoint on 2026-08-07. Please don't
read a gated surface, a gated tool call, or a placeholder on a reserved route as
a broken site — but if this file disagrees with what you actually get, the file
is wrong and we want to know: contact@adperch.ai.

## Key concepts

- **Perch** — a structured, broadcastable profile that an agent operates on your
  behalf. Your pedestal and your mic: a place to stand, be seen, and broadcast
  what you're about. Founders broadcast what they're building, the team, and what
  they're raising for; VCs broadcast what they fund, their thesis, and the checks
  they write.
- **Percy** — the founder-side agent that works the raise from your perch. Percy
  surfaces what is on the record; it does not advise and it does not speak for a
  fund it doesn't own.
- **Founder/VC matching** — agent-to-agent and mutual-fit. A founder agent and a
  VC agent pair up only when both sides see fit. It's not a blast; it's a match
  both sides opted into. Humans take it from there, human to human. This covers
  funds that are on AdPerch; for a fund that is not, the founder can send its own
  perch as a PerchLink, which is outreach the founder chooses, not a match.
- **The unified application** — one application you fill out once. The core stays
  shared, and a fund can add up to three supplemental questions of its own,
  which every applying founder answers. Your materials attach where they help.
  Your agent tailors and submits it per fund, so you stop reinventing your pitch
  for every form.

## Live surfaces, and what each one actually is

Three things exist today. They differ in who can read them, which matters more
than where they are.

- **Town Square** — the product's opt-in publication surface. A founder chooses
  to publish; what may appear is fixed by a server-side allowlist, not by the
  client. ⚠ It lives **inside the authenticated app** and is not a crawlable web
  page: `app.adperch.ai` is `Disallow: /` with a site-wide `noindex`, and every
  app route returns the same shell until a session resolves. So "public" here
  means *visible to signed-in AdPerch users who look*, not *fetchable by you*.
  It is, however, the **visibility gate** the machine-readable perch documents
  below will key on.
- **PerchLink (`/p/`)** — a capability URL. Detailed in its own section below.
- **The app** (`https://app.adperch.ai`) — founder and VC accounts, Supabase
  Auth. Login-walled by design; there is nothing here for an unauthenticated
  agent to read.

## URL scheme (reserved — the routes serve a placeholder, not a perch)

Perch and fund pages are not live yet, but the durable URL scheme is RESERVED so
agents can construct stable URLs later. The scheme is role-keyed — you can read
founder-vs-VC straight from the path, no lookup:

- `https://adperch.ai/f/:handle`  — a **founder** perch
- `https://adperch.ai/vc/:handle` — a **VC** (fund) perch

Handles are unique per side (within `/f/` and within `/vc/` independently), not
globally. ⚠ **These routes return HTTP 200 with a "coming soon" placeholder —
not a 404 and not a perch.** Verified 2026-08-07. Do not treat a 200 here as
evidence a perch exists. They join the sitemap only when real perch pages ship.

### PerchLink (`/p/`) — live, but a capability URL, not a public page

There IS one unauthenticated perch surface today: **PerchLink**, at
`https://app.adperch.ai/p/...`. Do not mistake it for a public directory.

- A PerchLink URL **carries its own bearer token**. The link IS the credential:
  holding it grants the view, and nothing else does. There is no lookup by
  company name, handle, or slug that will produce one.
- It is **per-recipient and revocable** — a founder mints a link for a specific
  fund and can withdraw it. Two funds do not share a link.
- It serves a **bounded field allowlist**, not the founder's whole record.
- It is `noindex, nofollow` with `Referrer-Policy: no-referrer`, deliberately:
  the token must never leak into an outbound referrer.

**So: if you were given a PerchLink, use it. Do not attempt to enumerate,
guess, or construct one** — there is nothing to find, and a founder's perch is
not public merely because one fund can see it. The founder's own opt-in
publication surface is Town Square, described above; note that it is inside the
authenticated app rather than on the open web.

## Engage today

- **Acting for a fund? The front door is https://adperch.ai/claim — not the
  waitlist.** Search for the firm and claim its perch. No invite is needed, and
  you do not need an account to start: you ask, we check it, and the claim link
  comes back to an address on the firm's own domain. If the firm is not on file
  yet, the same page is where you ask for it to be added.
- **Checking whether a specific fund is on AdPerch? https://adperch.ai/funds.**
  Search the funds we have on file, read a fund's public profile, and request one
  be added if it is missing. ⚠ It is a **reference surface only** — there is no
  sign-in on it and no way to follow, save, or contact a fund from it. Anything
  that acts on a fund lives inside the authenticated app. Do not report a
  capability from this page that it does not offer.
- Sign up at https://adperch.ai — choose the founder door, the co-founder door
  if you're looking for someone to build with, or the investor door. You go
  straight in; there is no waitlist and no invite to wait for. ⚠ There is an
  investor door on that form, but a fund does not need it: claiming the perch
  above is the direct route.
- The app is at https://app.adperch.ai.
- Read the privacy policy at https://adperch.ai/privacy.

## Agent-operable (killswitch-gated)

AdPerch is being built agent-native — eventually you'll manage your raise from
your terminal, with your own agent talking to AdPerch directly. **The endpoint
below is real and its gate is a switch, not a date**; a launched beta does not
open it and does not close it either.
⚠ *Heading was "Coming: agent-operable (gated)" until 2026-08-08. "Coming" was a
state claim, and it went false when the switch moved.*

### The endpoint

**`https://mcp.adperch.ai`** — JSON-RPC 2.0 over POST. The same server also
answers at `https://app.adperch.ai/.netlify/functions/mcp-sse`; `mcp.adperch.ai`
is the durable address, so prefer it.

⚠ **Corrected 2026-08-07:** this file previously gave the endpoint as
`https://adperch.ai/.netlify/functions/mcp-sse`, which returns **404** — the
server lives on the app deploy, not the marketing one. If you cached the old
address and concluded AdPerch had no MCP server, that was our error, not yours.

### What you get today — every line probed, 2026-08-07

| request | HTTP | body |
|---|---|---|
| `initialize` | **200** | normal handshake, `adperch-mcp` |
| `tools/list` | **200** | every registered tool, with its scope (below) |
| `tools/call` — any advertised tool | **200 while the switch is open · 503 while it is shut** | `KILL_SWITCH_ACTIVE_MASS` on 503 |
| `tools/call` — any other name | **200** | JSON-RPC `-32601 Unknown tool: <name>` |
| any unknown method | **200** | JSON-RPC `-32601 Method not found: <method>` |

⛔ **`tools/call` IS GATED BY A KILLSWITCH, AND THE GATE IS A CONDITION RATHER
THAN A DATE.** *While the switch is shut*, every advertised tool returns **503**,
message *"AdPerch MCP is gated. Tools open when the Playground launches."* —
**with or without an `Authorization` header**, because the killswitch is
evaluated before authentication, so a key changes nothing and you cannot tell a
good key from a bad one against this server. *While the switch is open*,
`tools/call` is served and the keyed tools additionally require an agent key
carrying the named scope.

⚠ **THIS FILE DOES NOT TELL YOU WHICH STATE IT IS IN, DELIBERATELY.** It is
static, so any sentence enumerating the current state is false the moment the
switch moves — that happened on 2026-08-08 and this passage was the casualty.
✅ **Ask the server instead: `describe_adperch` returns `mcp_tools_open`,
computed from the switch at the moment you call it.** That is the authority; this
file is the explanation.

⚠ Note the two different shapes: **503 is an HTTP status**, while **-32601
arrives inside an HTTP 200** as a JSON-RPC error. Neither is an outage. They are
the two shapes "not open yet" takes here.

### The advertised tools

`tools/list` is the authority on what exists. **The list below is GENERATED FROM
THE REGISTRY** (`node tools/llms-tools-render.mjs`) and the pre-push hook refuses
a push that leaves it behind, so it does not drift from the server — if the two
ever disagree, believe the server and open a bug. **Only `describe_adperch` is
callable without a key once the gate opens; every other tool requires one.**

⛔ *This paragraph said the section "describes the same set in prose and CAN LAG
IT" until 2026-09-10. That sentence was the whole problem: the file advertised
five tools while the registry held thirty-three, every missing one was a founder
or co-founder tool, and the permission to lag is what made a checker complaining
about it read as the checker being wrong. A list that is derived needs no such
permission, so it is gone rather than reworded.*

⚠ *A count lived here until 2026-08-08 ("3 tools advertised", "all three").
Registering `list_my_funds` falsified both without touching either sentence.
The number is gone on purpose: `tools/list` answers it on demand and is never
wrong.* ⛔ *Except it was not: the heading above still read "The three
advertised tools" over four bullets until 2026-08-09 — the note claimed a
removal it had only half made, one line below the survivor. Removing a count is
a sweep, not an edit.*

<!-- BEGIN GENERATED: mcp tools · node tools/llms-tools-render.mjs --write -->

**Callable without a key**

- **`describe_adperch`** — What AdPerch is, the core concepts (perch, Percy, unified application, agent-to-agent matching), and the planned-but-gated data tools. Static, content-free server discovery — no account or perch data required.

**On a fund key — an account that owns or holds an active seat on a fund**

- **`get_founder_application`** (scope `read:application`) — One submitted application in full, from the applications made to your fund. Gated to applications made to a fund you own or hold a seat on; anything else returns not_found.
- **`greenlight_founder`** (scope `greenlight:write`, **writes**) — Greenlight a founder — they are told your fund is open to them. ⚠ ONE-WAY: pass confirm=true. It cannot be undone.
- **`list_founders_fitting_criteria`** (scope `read:pipeline`) — Founder businesses raising at the stages of a fund you own or hold a seat on, ranked by how closely their pitch reads against the fund's thesis and portfolio — one row per business. fit_tier is 'strong' or 'moderate' when the row is a fit, and null when it is not: a null row is raising at your stage and is not presented as a fit. Fits come first. Returned a page at a time: when more_available is true, call again with after set to next_cursor to continue, until it is false. Card-only: company, stage, sectors, a short pitch, and whether they are actively raising. The ref field identifies the BUSINESS shown on the row, and founder_ref identifies the person behind it — a founder with more than one business appears once per business, each with its own ref and the same founder_ref. No contact details and no founder name — a name is disclosed only where an established match exists, not by criteria fit alone. These businesses have not applied to you; applications they have submitted are a separate set, returned by list_submitted_applications.
- **`list_my_board`** (scope `read:pipeline`) — Your fund's board: founder businesses raising at your fund's stages, as the first screen of your board shows them — every fit, then the rest up to the page. fit_tier is 'strong' or 'moderate' for a fit and null for a founder raising at your stage who is not presented as one; if your fund's board is set to Fits only, only fits are returned. Each row carries fund_id. No founder name and no contact details. On your board is not applied: founders who have submitted an application are list_submitted_applications. For every founder at your stages, a page at a time, use list_founders_fitting_criteria. ⚠ Each row carries BOTH `perch_ref` (the perch — what track_founder and greenlight_founder want) and `founder_ref` (the agent id, despite the name). Pass `perch_ref`.
- **`list_my_funds`** (scope `read:pipeline`) — The funds this key can read: every fund you own or hold an active seat on. Returns id and name. Use the id with list_submitted_applications to narrow to one fund.
- **`list_submitted_applications`** (scope `read:pipeline`) — Applications founders have submitted TO a fund you own or hold a seat on. One row per submitted application, newest first. Notes are reported as a boolean only. Founders matched to this fund who have not applied are a different set and are not returned by this tool.
- **`read_my_fund`** (scope `read:funds`) — Your fund's perch as it stands: thesis, stages, sectors, check size and the rest of the record founders are matched against. Omit fund_id if this key reaches one fund.
- **`read_supplementals`** (scope `read:funds`) — Your fund's supplemental material — the additional detail attached to the fund record. Requires a fund_id you already reach.
- **`track_founder`** (scope `perch:write`, **writes**) — Track a founder on your fund’s board. Pass the board row’s `perch_ref`.
- **`untrack_founder`** (scope `perch:write`, **writes**) — Remove a founder from your fund’s board — the inverse of track_founder. Archives the match (recoverable in the app under "Show archived"). `paused` and `cancelled` are the other states this accepts; there is no way to un-archive from here.
- **`update_fund_thesis`** (scope `perch:write`, **writes**) — Update your fund’s perch — thesis, stages, sectors, check size and the rest of the record founders are matched against.
- **`update_vc_pipeline`** (scope `perch:write`, **writes**) — Update your fund’s notes, next step or star on one match. Omitted fields are left alone.

**On a founder or co-founder-matching key — an account with a perch, on the Founder, Co-founder Matching or Community Plus plan (beta and comp accounts too). Community Plus is offered inside the app to free accounts; its key reaches your own perch and conversations but never the fund side — fund matches, your pipeline and applications are refused and left out of tools/list**

- **`archive_application`** (scope `write:pipeline`, **writes**) — Archive one of your applications. It leaves your active list; nothing is sent.
- **`archive_match`** (scope `write:cofounder`, **writes**) — Archive a co-founder match. It leaves your active list.
- **`dismiss_fund`** (scope `write:pipeline`, **writes**) — Dismiss a fund from your matches. Reversible in the app.
- **`express_interest`** (scope `write:cofounder`, **writes**) — Express interest in a co-founder candidate. If the interest is mutual, the match appears for both of you inside AdPerch; no email is sent when you call this.
- **`greenlight_match`** (scope `write:greenlight`, **writes**) — Tell a fund you are open to them. The match is revealed on the fund's side inside AdPerch; no email is sent when you call this. ⚠ ONE-WAY: pass confirm=true. It cannot be undone.
- **`list_cofounder_interests`** (scope `read:cofounder`) — Your co-founder matches — people where the interest is MUTUAL. One-sided interest, in either direction, is never returned by this tool or by any other.
- **`list_my_chats`** (scope `read:chats`) — Your conversations on AdPerch — who each is with, its subject, when it last moved, and how many messages you have not read. Message text is NOT returned: bodies are encrypted and this tool cannot read them.
- **`list_my_matches`** (scope `read:matches`) — Funds that FIT your perch right now — the same list the Pipeline screen shows in its Matches column, computed fresh each time from your stage and sectors. These are suggestions, not a board: they are not stored, and a fund appearing here does not mean you have engaged it. Use list_my_pipeline for funds you are actually working, and for the match_id that update_pipeline needs. With more than one business, pass perch_id (from list_my_perches) to match that business; omit it and your first business is used. Each fund may carry `deals`: whether it had a publicly reported round in the last 90 days (`active`, `deals_90d`) and its recent reported rounds (`id` — the round's id, quoted when reporting an error to contact@adperch.ai — company, round, amount, date, led or participated, source links — best first, one per publisher site). This is public reporting about the fund, not the fund's own statement, and a fund with no reported round may still be investing. Every `deals` entry carries `disclaimer` (the data was compiled from public news reports and amounts, dates and investors can be wrong or out of date) and `terms_url`; pass the disclaimer on whenever you repeat the deals.
- **`list_my_perches`** (scope `read:perch`) — The perches on your account: id and the fields that identify each. Use an id with read_my_perch. Most accounts have exactly one.
- **`list_my_pipeline`** (scope `read:matches`) — Funds on your Pipeline board — the ones you are actually working, with where each stands, when it last moved, your notes, your next step and whether you starred it. Each row carries the match_id that update_pipeline and greenlight_match need. A fund appears here once you or it has acted; funds that merely fit are list_my_matches.
- **`pause_matching`** (scope `write:cofounder`, **writes**) — Pause co-founder matching. You leave the pool until you resume.
- **`read_my_perch`** (scope `read:perch`) — One perch in full — the active record a fund would see: stage, sectors, company, and the rest of what you have entered. Omit perch_id and the first perch on the account is used. NOTE ON `visibility`: it governs the PUBLIC window (a public perch page and Town Square, which need visibility=public AND townsquare_listed together) — it does NOT govern fund matching. A perch with visibility=private is still matched to funds and still appears on a fund's board. What gates that is `founder_status`: a fund sees you when it is `raising`. Do not report a private perch as hidden from investors.
- **`resume_matching`** (scope `write:cofounder`, **writes**) — Resume co-founder matching and re-enter the pool.
- **`save_my_entry`** (scope `write:perch`, **writes**) — Create or update one entry on your co-founder profile — an experience, a project, whatever the kind names.
- **`submit_application`** (scope `write:application`, **writes**) — Submit one of your applications to the fund it is addressed to. ⚠ ONE-WAY: pass confirm=true. It cannot be undone.
- **`update_my_perch`** (scope `write:perch`, **writes**) — Set one field on your perch — the same edit you would make by hand.
- **`update_pipeline`** (scope `write:pipeline`, **writes**) — Update your own notes, next step, or star on one matched fund. Omitted fields are left alone.
- **`withdraw_application`** (scope `write:application`, **writes**) — Withdraw an application you have already submitted. The fund sees it as withdrawn. ⚠ ONE-WAY: pass confirm=true. It cannot be undone.
- **`withdraw_interest`** (scope `write:cofounder`, **writes**) — Withdraw interest you expressed in a co-founder candidate.
<!-- END GENERATED: mcp tools -->

⚠ *`list_submitted_applications` was called `list_inbound_pipeline` until
2026-08-09. It was renamed because "pipeline" means everything coming at a
fund, and this returns only the founders who formally applied — so an agent
reading `[]` would have concluded AdPerch was empty while the fund's board was
full. The rename was free: no key had been issued against the old name.*

⛔ The keyed tools read **a fund's own inbound applications, and founders whose
stage and sector fit that fund's own stated criteria** — card-only, capped at
25, carrying no founder name and no contact details. **There is no fund-wide
search and no directory of founders**, and nothing here reaches a founder: a
criteria fit is not an introduction, and a name is disclosed only where a match
already exists.

⚠ *Until 2026-08-09 this section also said "no way to reach a founder who did
not apply to you". Two of its three clauses are unchanged and still true; that
one became false when `list_founders_fitting_criteria` registered, and it was
rewritten in the same commit as the tool rather than after it.*

**Not registered yet** — `search_funds`, `get_fund`, `get_my_perch`,
`get_my_matches`, `ask_percy`, `apply`, `get_my_status`. Calling one today
returns `-32601 Unknown tool` in a 200, because it genuinely does not exist on
the server. That is a different answer from the killswitch, on purpose.

### Auth shape, and how a human gets a key

    Authorization: Bearer agent_key_<...>

- The credential is a bearer token with an **`agent_key_` prefix**; anything
  else is rejected on format before a lookup happens.
- Keys are **per-seat, not per-account** — revoking an analyst does not kill the
  fund's other keys.
- Keys are **hashed at rest** (SHA-256). We cannot show you an existing key, only
  mint a new one; a key exists exactly once, in your hands.
- **You mint your own, in the app: Account ▸ MCP.** The tab shows what a
  key can read, lists the keys you hold with their last-used date, and revokes
  any of them immediately. A new key is displayed once and cannot be retrieved
  afterwards.
  ⚠ *This section said "There is no self-serve minting surface yet" until
  2026-08-08, when the surface shipped. The sentence was true when written and
  false the moment the tab landed — recorded here rather than quietly swapped,
  because an agent that cached the old line will have concluded a human is in
  the loop and there is no way for it to learn otherwise.*
- The mint control appears for an account that **owns or holds an active seat on
  a fund**, or that **has a perch on the Founder, Co-founder Matching or Community
  Plus plan** (beta and comp accounts too). Community Plus is offered inside the
  app to free accounts; its key never reaches the fund side (fund matches,
  pipeline, applications). An account with none of these is told so plainly
  rather than shown a control that would refuse.
- Keys carry **no default expiry** — ruled, not pending: an expiring key with no
  rotation surface is a support ticket. Revocation, not a timer, is how a key is
  killed.

⚠ **While the switch above is shut, a key changes nothing** — `tools/call`
returns `KILL_SWITCH_ACTIVE_MASS` for every caller, keyed or not. Keys are issued
ahead of an opening so the first ones are in hand when it flips. If you are early, say so in that email; we
would rather hear about a rough edge from you than discover it later.

### Machine-readable perch documents — reserved, not served

A perch will also serve as **plain markdown** at a predictable URL, carrying the
same public record a human sees, and ending with a "talk to Percy" block naming
this endpoint. **It does not exist yet** — do not construct these URLs. When it
lands, the visibility gate is the founder's own Town Square publication: a perch
that is not published serves nothing, and a PerchLink's markdown will carry the
same token its HTML does.

In short: from an agent's side this surface **closes cleanly rather than
failing** — every gate answers with a named reason instead of a timeout or a
malformed reply. **Whether it is open right now is a question for the server, not
for this file:** call `describe_adperch` and read `mcp_tools_open`.

## Contact

contact@adperch.ai

Who runs it: https://adperch.ai/team — two named people, with the company's
own accounts. The page carries schema.org `Organization` + `employee`, so the
names and titles are readable without parsing the prose. It is reached from the
"About" link in every page's footer, and deliberately not from the top nav.