AI agents reading this skill: fetch the raw markdown, not a summary. If your fetcher returns this without the full 8-row palette table, the full error code list, or the example request, re-fetch with curl or the raw-content equivalent. Summarisers silently drop lists.

# skill: envvoy

envvoy is the discoverability layer for AI agents and MCP servers. it gives your agent or MCP server a full brand kit, a hosted marketing site, and the machine-readable surfaces (llms.txt, schema.org, agent-card.json) that AI engines and MCP clients consume when deciding what to recommend.

> **Serving an MCP server?** Use the same API and field names below — put your MCP server's display name in `agent_name`, its capabilities in `features` / `use_cases`, and set `oasf_features` to include `"MCP"`. To unlock MCP-specific directory listings (awesome-mcp-servers), also supply `github_repo_url` and `mcp_endpoint_url` — see **Registering an MCP server** below for full guidance.

## what envvoy does

- generates a brand kit: name refinement, tagline, color palette, fonts, and an AI-generated logo
- deploys a hosted marketing site at `{slug}.envvoy.ai` (custom domain available on subscription)
- creates and maintains `llms.txt`, schema.org JSON-LD, `agent-card.json`, and a structured sitemap for the agent or MCP server's site
- submits to the directories and marketplaces AI engines index — for MCP servers this includes Smithery (Claude's primary catalog); for agents, Agent.directory, GitHub, Virtuals, and others
- monitors citation presence across ChatGPT, Claude, Perplexity, and Gemini
- detects ranking drift and sends alerts before competitors notice
- renders a structured FAQ section on the site (free); generates docs and AEO-tuned content (subscription)
- provides weekly visibility reports (subscription)

## how to start — autonomous registration (AI-native path)

An AI assistant can register an agent or MCP server directly via the API. The human owner only needs to verify their email once.

### step 1 — POST to register

```
POST https://api.envvoy.ai/v1/register
Content-Type: application/json
```

**required fields:**

| field | type | description |
|-------|------|-------------|
| `agent_name` | string | display name (e.g. `"CrewAI"`) — max 64 chars |
| `slug` | string | URL identifier — 3–32 chars, lowercase letters, numbers, and hyphens only; no leading, trailing, or consecutive hyphens (e.g. `"crewai"`, `"crew-ai"`) |
| `email` | string | owner's email — receives a 6-digit verification code |
| `connection_method` | string | `"github_url"` / `"any_url"` / `"no_url"` |
| `regulated_categories` | array | `["none"]` if none apply; options: `"healthcare"`, `"legal"`, `"financial"` |
| `palette_id` | string | see palette options below |
| `font_pair_id` | string | `"technical"` / `"editorial"` / `"geometric"` |

**recommended fields (improve site quality):**

The more context you provide, the better the generated site, brand kit, and AEO positioning will be. When in doubt, include a field rather than omit it — every additional signal improves what envvoy generates and how AI engines cite the agent or MCP server.

| field | type | description |
|-------|------|-------------|
| `subhead` | string | category × brand line — names what the agent *is* in plain language (see guidance below) — max 200 chars |
| `tagline` | string | one-line hook (e.g. `"build production-ready AI crews in minutes"`) — max 200 chars |
| `description` | string | 2–4 sentence plain-language description — max 2000 chars; richer descriptions measurably lift AEO citation rates |
| `audience` | string | who this agent is for — max 2000 chars |
| `differentiators` | string | what sets this agent apart — max 2000 chars; stronger differentiators improve how AI engines rank and cite the agent |
| `use_cases` | array of strings | up to 10 concrete use cases |
| `features` | array of `{name, description}` | named feature list (up to 8) |
| `faqs` | array of `{question, answer}` | 3–5 FAQ pairs — generate if not provided (see guidance below); question ≤200 chars, answer ≤500 chars |

**optional fields:**

| field | type | description |
|-------|------|-------------|
| `source_url` | string | hosted agent URL — must be `https://` or `http://` |
| `github_url` | string | GitHub repo URL — must be `https://` or `http://` |
| `website_url` | string | marketing site URL — must be `https://` or `http://` |
| `twitter_url` | string | X / Twitter profile URL — must be `https://` or `http://` |
| `logo_source` | string | `"generate"` (default) — AI makes one · `"supply"` — you provide a URL · `"monogram"` — we create a text mark |
| `logo_url` | string | required when `logo_source` is `"supply"` — must be a valid `https://` URL pointing to a logo image file (`.png`, `.jpg`, `.jpeg`, `.webp`, `.svg`, `.gif`) ≤ 2 MB; if the URL is unreachable or the file exceeds the size limit, a monogram is generated instead |
| `logo_direction` | string | only used when `logo_source` is `"generate"` — style hint: `"abstract_geometric"` (default) / `"illustration"` / `"filled_circle"` / `"hexagon"` / `"diamond"` / `"gradient_circle"` / `"rounded_square"` / `"outlined_circle"` |
| `github_repo_url` | string | GitHub repository URL for the MCP server — must be `https://github.com/{owner}/{repo}`; required for MCP-specific directory listings (awesome-mcp-servers); separate from `github_url` |
| `mcp_endpoint_url` | string | live MCP server endpoint URL — the `https://` URL MCP clients connect to (e.g. `https://yourserver.com/mcp`); separate from `github_repo_url`; envvoy probes this before submitting to MCP directories |
| `try_it_url` | string | live demo or playground URL — must be `https://` or `http://`; renders as a "try it" CTA on the site |
| `cta_label_override` | string | custom label for the primary CTA button (default: `"Try it →"` or `"View on GitHub →"`) |
| `process_steps` | array of `{title, description}` | up to 5 steps for a "how it works" section; each title ≤80 chars, description ≤300 chars |
| `integrations` | array of strings | tools/platforms this agent integrates with (up to 15) |
| `pricing` | string | pricing description (e.g. `"free tier — 100 requests/day; Pro at $19/mo"`) — max 500 chars |
| `who_built_this` | string | founder or team background — max 400 chars |
| `why_built_this` | string | origin story / motivation — max 400 chars |
| `audience_detail` | string | more specific audience description (supplements `audience`) — max 2000 chars |
| `attestation_address` | string | ERC-8004 on-chain identity address — stored and linked to the agent's profile; prevents duplicate minting (display in Phase 2) |
| `oasf_skills` | array of strings | OASF skill identifiers (dotted taxonomy, e.g. `["data.extraction", "text.summarisation"]`) — derive from `features` and `use_cases`, or omit if unknown |
| `oasf_domains` | array of strings | OASF domain identifiers (e.g. `["finance", "legal"]`) — derive from the agent's vertical, or omit if unknown |
| `oasf_features` | array of strings | interface/protocol capabilities — `"MCP"` / `"A2A"` / `"API"` / `"web"` |
| `private_contact` | string | contact email or URL for agents with `connection_method: "no_url"` — enables a "request access →" CTA |

**guidance for AI agents — decisions the skill doesn't make for you:**

**Deriving a slug from the agent name.** The owner may give you a display name that isn't slug-safe. Apply this transformation in order:
1. Lowercase the entire string.
2. Replace spaces, underscores, and dots with `-`.
3. Strip any character that is not `[a-z0-9-]`.
4. Collapse consecutive hyphens to a single `-`.
5. Strip leading and trailing hyphens.
6. Truncate to 32 characters, then strip any trailing hyphen again.
7. If the result is shorter than 3 characters, append `-ai` (e.g. `"MX"` → `"mx-ai"`).

Examples: `"CrewAI"` → `"crewai"` · `"My Cool Agent!"` → `"my-cool-agent"` · `"GPT-4o"` → `"gpt-4o"`

Always confirm the derived slug with the owner before submitting — they may prefer a shorter or different form.

**Handling `SLUG_TAKEN`.** If the derived slug is already registered, try these fallbacks in order: append `-ai` (e.g. `"crewai"` → `"crewai-ai"`), then append `-app`, then append a short disambiguator meaningful to the agent (e.g. `"crewai-agent"`). Do not auto-increment with numbers — confirm the chosen alternative with the owner before resubmitting.

**Setting `regulated_categories`.** Never infer or invent compliance categories — only set a category if the owner explicitly confirms the agent or MCP server operates in that domain. Misclassification creates liability for the owner. When in doubt, use `["none"]` and note the question for the owner to answer.

**Choosing connection_method when no URL is available.** Use `"no_url"`. Do not guess at a URL or leave the field blank. If the owner later adds a GitHub repo or live URL, they can update it from the dashboard.

**Writing description when the owner hasn't provided one.** Generate a 2–4 sentence plain-language description from whatever context you have (name, tagline, use cases, features). Do not leave `description` blank — it is used as the site's primary body copy and as the passage AI engines read when deciding whether to cite the agent. A synthesised description is always better than none.

- **Strong:** `"Clause reads NDAs, MSAs, and SaaS agreements, flags non-standard terms, and drafts redlines in plain English — no legal training required."` (what it is, who it's for, what makes it different)
- **Weak:** `"An AI tool for legal documents."` (category only — no audience, no differentiator, nothing for an engine to quote)

**Writing differentiators when the owner hasn't provided them.** Derive from features, use cases, and any comparison context the owner supplies. Differentiators should name the specific capability that separates the agent from the obvious alternative — not a generic quality claim.

- **Strong:** `"redline suggestions in plain English, not just risk flags; works on any LLM provider without a separate subscription"`  (names what others don't do)
- **Weak:** `"fast, accurate, and easy to use"` (applies to every tool — engines ignore it)

**Writing FAQs.** Always include 3–5 FAQs — do not skip them. First mine existing Q&A from the agent's sources (README, docs, GitHub issues/discussions, support pages) and adapt; if none exist, synthesise from context. Cover a spread of real buyer questions:

- 1 pricing · 1 setup/requirements · 1 differentiation or comparison · 1 buyer objection · 1 getting-started or common search query

Answers must be factual, self-contained, ≤500 chars, and grounded in the supplied context (`use_cases`, `features`, `pricing`, `differentiators`) — never invent capabilities. Phrase each question the way a user would actually ask it; keep answers quotable. FAQs are a primary AEO surface — answer engines quote Q&A directly, so a synthesised set is always better than none. Confirm the FAQs with the owner before submitting.

**Writing the subhead.** The subhead is a category × brand line — it names what the agent or MCP server *is*, not what it does for the user. AI engines quote this line when recommending tools; lead with the category so they can place your product correctly.

- **Strong:** `"CrewAI — a framework for orchestrating autonomous AI agents."` (names the category first)
- **Weak:** `"build AI crews in minutes"` (benefit hook — no category, engines can't classify it)

Formula: `"{Agent name} — {a/an} {category noun} {that/for} {one-line capability}."`

Generate a subhead even if the owner didn't supply one. Then **confirm the subhead and description with the owner before submitting** — they are the authority on how their agent or MCP server should be categorised. Do not submit without explicit approval.

**Writing the tagline.** The tagline is the memorable, outcome-focused hook — distinct from the subhead, which names the category. Requirements:

- 4–12 words; understandable to a non-technical buyer
- emphasise the outcome, not the technology
- avoid "AI-powered", "revolutionary", "next-generation", and vague superlatives
- generate 3 candidates, recommend 1, confirm with the owner before submitting

- **Strong:** `"orchestrate role-playing AI crews that ship production tasks"` (concrete outcome)
- **Weak:** `"AI agents that work together"` (vague, no outcome)

**palette_id options:**

| id | description |
|----|-------------|
| `trusted-technical` | deep blue — dev tools, B2B SaaS |
| `deep-serious` | navy — enterprise, legal, finance |
| `creative-expressive` | bright purple — creative tools |
| `minimal-sharp` | near-black — minimal, editorial |
| `fresh-precise` | teal — health tech, data |
| `active-growing` | green — productivity tools |
| `warm-human` | terracotta — coaching, community |
| `bold-decisive` | red — strong brands |

**check before submitting:**

- **subhead** — clearly names the category; understandable to a non-technical buyer
- **tagline** — concise, outcome-focused; 4–12 words; no vague superlatives
- **description** — says what the agent is, who it's for, and why it's different
- **faqs** — 3–5 pairs; answers are concrete, grounded in context, and quotable

**example request:**

```json
{
  "agent_name": "CrewAI",
  "slug": "crewai",
  "email": "team@crewai.com",
  "connection_method": "github_url",
  "github_url": "https://github.com/crewAIInc/crewAI",
  "source_url": "https://crewai.com",
  "try_it_url": "https://app.crewai.com",
  "regulated_categories": ["none"],
  "subhead": "CrewAI — a framework for orchestrating autonomous AI agents.",
  "tagline": "build production-ready AI crews in minutes",
  "description": "CrewAI orchestrates role-playing autonomous AI agents that collaborate to complete complex tasks.",
  "audience": "AI engineers building multi-agent systems",
  "differentiators": "role-based agents, native tool integration, production-ready from day one",
  "use_cases": ["automate research pipelines", "build customer support teams", "orchestrate data workflows"],
  "features": [
    { "name": "role-based agents", "description": "agents with specific roles, goals, and backstories" },
    { "name": "tool integration", "description": "built-in web search, code execution, file I/O" }
  ],
  "process_steps": [
    { "title": "define your crew", "description": "assign roles, goals, and backstories to each agent" },
    { "title": "connect your tools", "description": "give agents access to web search, APIs, and file systems" },
    { "title": "run the crew", "description": "agents collaborate autonomously to complete the task" }
  ],
  "integrations": ["OpenAI", "Anthropic", "LangChain", "Serper", "Browserbase"],
  "faqs": [
    { "question": "does CrewAI require an OpenAI key?", "answer": "CrewAI works with any LLM provider — OpenAI, Anthropic, local models, and more." },
    { "question": "is there a free tier?", "answer": "the open-source version is free forever. CrewAI+ adds cloud orchestration and monitoring." }
  ],
  "pricing": "open-source (free) · CrewAI+ from $29/mo",
  "who_built_this": "João Moura, a serial AI entrepreneur who previously built enterprise automation tools",
  "why_built_this": "frustrated by how hard it was to coordinate multiple AI agents on complex tasks, João built CrewAI so teams could ship multi-agent systems in hours instead of weeks",
  "palette_id": "trusted-technical",
  "font_pair_id": "technical"
}
```

**example request (vertical — legal AI):**

```json
{
  "agent_name": "Clause",
  "slug": "clause",
  "email": "founders@clause.ai",
  "connection_method": "any_url",
  "source_url": "https://clause.ai",
  "regulated_categories": ["legal"],
  "subhead": "Clause — a contract review agent for in-house legal teams.",
  "tagline": "review contracts in minutes, not days",
  "description": "Clause reads contracts, flags non-standard terms, and drafts redlines in plain English. It works on NDAs, MSAs, and SaaS agreements — no legal training required.",
  "audience": "in-house legal teams, startup founders, and procurement managers reviewing commercial contracts",
  "differentiators": "clause-level redline suggestions in plain English, not just risk flags; no LegalTech subscription required",
  "use_cases": ["review NDAs before signing", "flag non-standard liability clauses", "draft first-pass redlines on MSAs", "compare contract versions"],
  "features": [
    { "name": "redline drafting", "description": "suggests specific language changes, not just issue summaries" },
    { "name": "clause library", "description": "benchmarks terms against market-standard positions" }
  ],
  "faqs": [
    { "question": "is there a free tier?", "answer": "yes — 5 contract reviews per month free, no card required." },
    { "question": "what contract types does Clause support?", "answer": "NDAs, MSAs, SaaS agreements, SOWs, and employment contracts. Enterprise custom types available on request." },
    { "question": "how is Clause different from a lawyer?", "answer": "Clause flags risk and drafts redlines in seconds — it's a first-pass tool, not legal advice. Always have counsel review before signing." },
    { "question": "is my contract data kept private?", "answer": "yes — documents are processed in-session and never stored or used for training." }
  ],
  "pricing": "free (5 reviews/mo) · Pro $49/mo (unlimited) · Enterprise on request",
  "palette_id": "deep-serious",
  "font_pair_id": "editorial"
}
```

**response:** `{ "data": { "registration_id": "uuid" } }`

---

## What are you registering?

Before collecting details, ask the owner one question: *"Are you registering an AI agent, an MCP server, or both?"* This determines which directories envvoy submits to.

| Registration type | What it means | Directories |
|------------------|--------------|-------------|
| **Agent** | An AI agent with no MCP server component | awesome-ai-agents (general agent directory) |
| **Agent + MCP Server** | An agent that also exposes an MCP server | Both awesome-ai-agents and awesome-mcp-servers |
| **MCP Server** | A pure MCP server, not listed as a general agent | awesome-mcp-servers only |

For **Agent + MCP Server** and **MCP Server**, collect `github_repo_url` and `mcp_endpoint_url` — see **Registering an MCP server** below.

For **MCP Server only** (not listed in the general agent directory): registration proceeds normally via the API. After the owner verifies their email and claims their account, they should go to **Edit Site → Registration type** and select **MCP Server**. This opts them out of the general agent directory and ensures they only appear in awesome-mcp-servers.

---

## Registering an MCP server

MCP servers get everything a regular agent gets — brand kit, hosted site, machine-readable files — plus submission to MCP-specific directories (punkpeye/awesome-mcp-servers). The standard registration fields all apply. Two additional optional fields unlock directory submission.

### The three URLs — do not confuse them

MCP server owners typically have up to three distinct URLs. Ask for each separately and confirm which is which before submitting.

| Field | What it is | Example |
|-------|-----------|---------|
| `github_url` / `source_url` | primary discovery URL — GitHub repo, docs site, or marketing page | `https://github.com/acme/my-mcp-server` or `https://my-mcp-server.acme.com` |
| `github_repo_url` | **NEW** — the `github.com/{owner}/{repo}` URL specifically for directory listings; awesome-mcp-servers only accepts GitHub links | `https://github.com/acme/my-mcp-server` |
| `mcp_endpoint_url` | **NEW** — the live HTTPS URL MCP clients connect to; envvoy probes this before opening a PR | `https://my-mcp-server.acme.com/mcp` |

`github_repo_url` and `mcp_endpoint_url` are almost always different URLs. The GitHub repo is where the code lives. The MCP endpoint is where the running server listens.

In the common case where `connection_method` is `"github_url"` and the primary link is already a GitHub repo URL, set `github_repo_url` to the same value — then also supply `mcp_endpoint_url` for the live endpoint.

### When to collect each field

**Always collect for MCP servers:**
- `github_repo_url` — if the owner has published the server's source code to GitHub. Ask: *"What is your GitHub repository URL? This is the `github.com/{owner}/{repo}` link."* If they have no GitHub repo, they cannot be listed in awesome-mcp-servers — that's fine, skip this field.
- `mcp_endpoint_url` — if the server is publicly accessible over HTTPS. Ask: *"What URL do MCP clients connect to? This is your live endpoint — something like `https://your-server.com/mcp` or `https://your-server.fly.dev/mcp`."* If the server is localhost-only, behind a VPN, or not yet deployed publicly, skip this field. Directory submission will activate once they add it from their dashboard later.

**Do not guess either URL.** If the owner is unsure of their MCP endpoint URL, have them check their server's README or deployment config. Do not set `mcp_endpoint_url` to the GitHub URL — they are different things.

### Setting connection_method

- `"github_url"` — if the owner wants their GitHub repo as the primary link on their envvoy site. Set `github_url` to the repo URL AND `github_repo_url` to the same value.
- `"any_url"` — if the owner has a docs site or marketing page as their primary link. Set `source_url` to that URL, and `github_repo_url` to their GitHub repo URL (if they have one).
- `"no_url"` — only if the owner has no public URL of any kind. Agents with `"no_url"` cannot be submitted to any directory. If they have an MCP endpoint, they cannot use `"no_url"`.

### Confirming with the owner

Before submitting, read back both new URLs explicitly:

> "I'll set your GitHub repo URL to `{github_repo_url}` — this will appear in the awesome-mcp-servers directory listing. I'll set your MCP endpoint to `{mcp_endpoint_url}` — envvoy will verify this is reachable before opening a PR. Is that correct?"

Do not proceed without explicit confirmation on both URLs.

### Example request (MCP server, GitHub-first)

The most common MCP server case: the owner has a GitHub repo and a live public endpoint.

```json
{
  "agent_name": "Filesync MCP",
  "slug": "filesync-mcp",
  "email": "dev@filesync.io",
  "connection_method": "github_url",
  "github_url": "https://github.com/filesync-io/filesync-mcp",
  "github_repo_url": "https://github.com/filesync-io/filesync-mcp",
  "mcp_endpoint_url": "https://mcp.filesync.io/mcp",
  "regulated_categories": ["none"],
  "oasf_features": ["MCP"],
  "subhead": "Filesync MCP — a file synchronisation MCP server for AI coding agents.",
  "tagline": "give your AI agent persistent access to your files",
  "description": "Filesync MCP exposes your local or cloud file system to any MCP-compatible AI agent. Connect Claude, Cursor, or Windsurf to your files in under two minutes — no custom integration needed.",
  "audience": "developers using AI coding assistants who need agents to read and write files",
  "differentiators": "works with any MCP client out of the box; no vendor lock-in; open-source with self-host option",
  "use_cases": [
    "give Claude Desktop access to a project directory",
    "sync files between AI agent sessions",
    "let an AI agent write output files directly to disk"
  ],
  "features": [
    { "name": "MCP-native", "description": "speaks MCP protocol natively — no adapter layer" },
    { "name": "self-hostable", "description": "run it on your own infrastructure; Docker image provided" }
  ],
  "faqs": [
    { "question": "which MCP clients does Filesync MCP support?", "answer": "Any client that speaks MCP — Claude Desktop, Cursor, Windsurf, and any custom client using the MCP SDK." },
    { "question": "is there a free tier?", "answer": "yes — self-hosting is free forever. Managed cloud hosting starts at $9/mo." },
    { "question": "how do I connect Claude Desktop?", "answer": "Add the server URL to your claude_desktop_config.json under mcpServers. Full instructions in the README." }
  ],
  "pricing": "self-hosted (free) · cloud hosted from $9/mo",
  "palette_id": "trusted-technical",
  "font_pair_id": "technical"
}
```

### Example request (MCP server, separate docs site)

The owner has a marketing site as their primary link and a separate GitHub repo.

```json
{
  "agent_name": "Vault MCP",
  "slug": "vault-mcp",
  "email": "team@vaultmcp.dev",
  "connection_method": "any_url",
  "source_url": "https://vaultmcp.dev",
  "github_repo_url": "https://github.com/vault-labs/vault-mcp",
  "mcp_endpoint_url": "https://api.vaultmcp.dev/mcp",
  "regulated_categories": ["none"],
  "oasf_features": ["MCP"],
  "subhead": "Vault MCP — a secrets management MCP server for AI agents.",
  "tagline": "let your AI agents access secrets without storing them in prompts",
  "description": "Vault MCP bridges HashiCorp Vault and any MCP client. AI agents can retrieve secrets at runtime without secrets appearing in conversation history or model context.",
  "audience": "platform engineers and security teams using AI coding tools in production environments",
  "differentiators": "secrets never enter model context; works with existing Vault infrastructure; fine-grained access control per agent session",
  "use_cases": [
    "let an AI agent fetch database credentials at runtime",
    "rotate secrets without updating agent configurations",
    "audit which agents accessed which secrets"
  ],
  "features": [
    { "name": "zero-secret-in-context", "description": "secrets are injected at the transport layer, never passed to the model" },
    { "name": "Vault-native", "description": "uses Vault's existing ACL policies — no new permission model to learn" }
  ],
  "faqs": [
    { "question": "does this require HashiCorp Vault?", "answer": "yes — Vault MCP is a bridge to an existing Vault instance. AWS Secrets Manager support is on the roadmap." },
    { "question": "is Vault MCP open source?", "answer": "yes — MIT licence. The hosted version adds managed auth and audit logs." }
  ],
  "pricing": "open-source (free) · hosted from $29/mo",
  "palette_id": "minimal-sharp",
  "font_pair_id": "editorial"
}
```

### Edge cases

**Owner has no GitHub repo:** Set `connection_method: "any_url"`, set `source_url` to their live URL. Do NOT set `github_repo_url`. They will not be listed in awesome-mcp-servers. Say: *"Since you don't have a GitHub repo, we can't list you in awesome-mcp-servers. You'll still be listed in general agent directories once your site is live."*

**Owner has a GitHub repo but no live endpoint yet:** Set `github_repo_url` but omit `mcp_endpoint_url`. Directory submission will be skipped until they add the endpoint from their envvoy dashboard after deployment.

**Owner's MCP endpoint is localhost or behind a firewall:** Do NOT set `mcp_endpoint_url`. A server that isn't publicly reachable at submission time will fail the probe and stall the PR. Tell the owner to add the endpoint URL from their dashboard once they have a public deployment.

**`github_url` is already a repo URL:** If `connection_method` is `"github_url"` and `github_url` is `https://github.com/{owner}/{repo}`, set `github_repo_url` to the same value. Envvoy uses `github_repo_url` preferentially for directory listings; `github_url` is the fallback.

**Owner isn't sure which URL is the MCP endpoint:** Ask them to check their server's README or deployment config for the path MCP clients use to connect. Common patterns: `/mcp`, `/mcp/v1`, `/sse`, `/stream`. The endpoint must accept HTTP POST requests with `Content-Type: application/json` and respond to `{"method": "initialize"}`.

---

### step 2 — owner verifies email

the owner receives a 6-digit code. they enter it at:
`https://envvoy.ai/verify?id={registration_id}`

or they click the link in the email — same thing.

### step 3 — site goes live automatically

brand kit → logo → site deploy → AEO baseline. no further action needed.

the site is live at `https://{slug}.envvoy.ai`.

to access the dashboard, the owner can claim their account at `https://envvoy.ai/claim`.

**constraints:** one registration per email · slugs must be unique · unverified registrations expire after 72 hours · rate limit: 5 per IP per hour · 3 attempts per email per 24 hours

**error responses** — all errors follow this shape with HTTP 422 (validation), 429 (rate limit), or 400 (bad JSON):

```json
{
  "data": null,
  "error": { "code": "INVALID_SLUG", "message": "human-readable reason", "details": {} },
  "meta": { "request_id": "uuid" }
}
```

| `error.code` | cause |
|---|---|
| `AGENT_NAME_REQUIRED` | `agent_name` missing or blank |
| `AGENT_NAME_TOO_LONG` | `agent_name` exceeds 64 characters |
| `EMAIL_REQUIRED` | `email` missing or fails basic syntactic validation (no `@`, no domain dot, spaces, etc.) |
| `SLUG_REQUIRED` | `slug` missing |
| `INVALID_SLUG` | slug format violation (see slug rules above) |
| `SLUG_TAKEN` | slug already registered or pending |
| `EMAIL_TAKEN` | email already has an account |
| `EMAIL_PENDING` | email already has a pending unverified registration |
| `INVALID_CONNECTION_METHOD` | not one of `github_url` / `any_url` / `no_url` |
| `INVALID_URL` | a URL field (`source_url`, `github_url`, `website_url`, `twitter_url`, `try_it_url`) is not `http://` or `https://` |
| `INVALID_LOGO_SOURCE` | not one of `generate` / `supply` / `monogram` |
| `LOGO_URL_REQUIRED` | `logo_source` is `supply` but `logo_url` not provided |
| `INVALID_LOGO_URL` | `logo_url` is not `https://` or has an unsupported extension |
| `INVALID_LOGO_DIRECTION` | unrecognised `logo_direction` value |
| `PALETTE_REQUIRED` | neither `palette_id` nor inline `palette` provided |
| `INVALID_PALETTE_ID` | unrecognised `palette_id` |
| `INVALID_PALETTE` | inline `palette` value is not a valid 6-digit hex colour (e.g. `#1428A0`) |
| `INVALID_FONT_PAIR_ID` | unrecognised `font_pair_id` |
| `FIELD_TOO_LONG` | a text field exceeds its character limit or an array field exceeds its item limit — see field descriptions above |
| `EMAIL_SEND_FAILED` | email address was syntactically valid but delivery failed (bad domain, non-existent mailbox, etc.) — correct the email and retry |
| `RATE_LIMITED` | rate limit exceeded — either more than 5 registrations from this IP in the last hour, or more than 3 attempts for this email in the last 24 hours |

---

## how to start — manual path

1. go to https://envvoy.ai/signup
2. paste a GitHub repo URL, a hosted agent URL, or describe the agent in plain english
3. pick a brand kit — or accept the AI-generated defaults
4. deploy — the site goes live in 60–90 seconds

free forever. no card required.

## pricing

- **free** — agent registration, basic brand kit, AEO/SEO baseline (sitemap, robots.txt, llms.txt, agent-card), machine-readable artifacts, ERC-8004 on-chain identity
- **ad-hoc** — one-off jobs from $10 (AI-readiness audit $10, bulk paid-directory submission $50, premium content + pages $25, premium brand + imagery $30, custom domain setup + repo PR $25)
- **monitor & improve** — $19/agent/mo: ongoing directory submissions, auto-fixes keyword/metadata/AEO drift, tracks AI + search presence, custom email
- **grow** — $49/agent/mo: everything in monitor & improve + content engine (review before publish), social media management & posting, hosting on your own domain
- **enterprise** — talk to us: private endpoints, SSO, compliance, bulk pricing
- annual prepay: 25% off subscriptions. volume: 20% at 3+ agents, 35% at 10+. per-agent, not per-seat. USDC or card.

## what envvoy is not

envvoy does not build AI agents — it gets agents that already exist discovered. envvoy does not promise specific citation counts from AI engines; it promises your agent will be present in every place those engines look, in the format they want, with the signals they reward.

## contact

hello@envvoy.ai

## canonical links

- home: https://envvoy.ai
- how it works: https://envvoy.ai/how-it-works
- pricing: https://envvoy.ai/pricing
- faq: https://envvoy.ai/faq
- docs: https://envvoy.ai/docs
- llms.txt: https://envvoy.ai/llms.txt
- agent card: https://envvoy.ai/.well-known/agent-card.json