Use the Aergos MCP to power your client work

MCP (Model Context Protocol) is an open standard that lets an AI agent operate software through typed tools rather than screens or brittle scripts. The Aergos MCP server exposes the platform's capabilities — list your clients, pull a client's organic competitors, read who AI engines cite instead of them, fetch rank history — as named operations an agent calls with structured, schema-validated arguments and gets structured results back.

The practical consequence: any data point in Aergos becomes available inside your agent's context as it writes. You do not export a CSV, switch tabs, and paste numbers into an email. You ask the agent for the email, and it fetches the live numbers itself before drafting. The MCP feature page has the full tool surface and the security model; this guide focuses on the outbound workflow.

You need three things, and the connection itself takes a couple of minutes:

1. An Aergos account on the Agency or Enterprise plan. The MCP server is included on both at no extra license cost — read tools, which power every workflow in this guide, are free to call.
2. An MCP-compatible client. Claude Desktop and Cursor are the common choices; any agent built on the official MCP SDKs works the same way. Add the Aergos MCP server to your client's configuration.
3. A scoped API token. Issue one from your Aergos workspace and paste it into your client config. Treat it like any other credential — keep it out of shared chats and source control.

Once connected, start every session the same way: call list_clients() and scope to a single client before you pull anything. The server enforces ownership on its side — it refuses cross-tenant reads even if an agent passes the wrong ID — but scoping first keeps your prompts unambiguous and your costs predictable.

For an agency, the MCP's first value is operational leverage across your whole book of clients. Instead of logging into each dashboard, your agent works the entire roster from one chat — scoped to the right client on every call, with ownership enforced on the server so nothing crosses tenants.

• Run the book in one pass. Loop list_clients and pull rank movement, new and lost keywords, and AI-citation changes for every client at once — a Monday digest without opening a single tab.
• Audit and triage on demand. Kick off a crawl for any client, read issues by severity, and hand back a prioritized fix list.
• Plan and produce content. Pull cluster gaps and striking-distance keywords, draft briefs, generate pages, and route them through approvals.
• Publish where the client lives. Push approved work straight to WordPress or Wix, then report on what moved across Search Console, GA4, rankings, and AI visibility.
• Stay inside guardrails. Reads are free; writes and paid scans need confirm; agency-pool credits and per-client meters are honored; every call is audit-logged.

Every module of the platform is exposed as typed tools, split into safe reads and confirmed writes. These are the operations you'll reach for most, grouped by category — the MCP feature page documents the full surface and each tool's input and output schema.

Reads — pulling competitors, rankings, citations, and analytics — are free and safe to call as often as you like. The handful that cost money are clearly metered and require an explicit confirm: request_crawl, request_analytics_scan, request_ai_visibility_scan, and request_page_generation.

Audits, content, and reporting are the obvious wins above. The use case most agencies never reach for is putting that same live data into the copy they send out. Scope to a client, have the agent pull the four reads that describe the competitive picture, and write the copy directly from them:

• get_organic_competitors — the rival domains taking the client's organic visibility, from the SEMRush-backed analytics scan.
• get_competitor_keyword_gaps — the exact keywords a competitor ranks for and the client does not, with volume.
• get_position_history — how the client's rankings moved over the window, so you can name a real slip or gain.
• get_competitor_citations — who ChatGPT, Perplexity, Gemini, and Google AI cite when they don't cite the client, per engine and prompt.

That same bundle drives three different outbound jobs:

The agent reads the data, then writes — a prospecting email that names the firm AI recommends in their market, a monthly client update whose competitive paragraph is specific instead of hand-wavy, or a set of ad angles built from the keywords a rival owns and the client doesn't. The copy is good because the inputs are true, not because the model is clever.

The reason this workflow converts is not that it adds data — it is that it changes the register of the message. A claim is either heard (your words, your metrics, easy to ignore) or registered (their reality, named and specific, impossible to wave away). Live Aergos data is what moves a line from the first column to the second:

Both sentences describe the same underlying fact. The left one dies on contact because it is abstract and about you. The right one lands because it names a rival the reader recognizes, a query their customers actually type, and an AI answer they can go verify in ten seconds. The agent can only write the right-hand version if it has the real data — which is exactly what the MCP gives it.

The power of this workflow is that every claim is real. Two guardrails protect that, and skipping either one undoes the whole advantage:

1. Verify the competitor is real before it ships. Models can confabulate a plausible-sounding firm name. Never let a named competitor reach a client-facing message unless it appears in the actual tool output — get_organic_competitors and get_competitor_citations return real domains, so cross-check the name against them. If it is not in the data, it does not go in the copy.
2. Self-exclude the client or prospect. If the data set happens to include the very business you are writing to, drop it. An email that names the recipient as their own competitor is an instant credibility kill — instruct the agent to exclude the scoped client's own domain from any "rival" it cites.

Outbound workflows are almost entirely read tools, which is what keeps them safe and inexpensive to run:

• Reads are free and safe. Pulling competitors, rankings, and citations changes nothing and bills nothing — run them as often as you like.
• Writes and scans require confirm. Requesting a fresh analytics or AI-visibility scan costs money and follows a two-step confirm pattern, so an agent loop can never trigger a charge behind your back.
• Every call is metered and logged. Billable calls return their cost in the response, and every call writes an audit entry — caller, client scope, tool, cost, outcome.
• Ownership is enforced server-side. Each client's data stays scoped to that client; the same boundary that protects the app protects your outbound workflows.

The full security and cost model — PII redaction, the confirm pattern, cost classes, and the kill switch — lives on the MCP feature page. The short version for outbound work: stick to reads and you stay free, safe, and fast.

Four prompts to drop into Claude or Cursor once the Aergos MCP is connected. Replace <client> with the client name and let the agent scope itself with list_clients() first:

Each one is read-only, so they are free to run and safe to iterate on. Build your own library from there — the pattern is always the same: scope a client, pull the real data, write from it.