# Resemble for AI agents

> You are reading Resemble's front door for AI agents. People get pages to read; agents get tools to call, with instructions written for them. Everything Resemble does for detection is available as tools on one MCP server: deepfake detection (audio, image, video), AI-written text detection, media intelligence, watermarking, Detect Agent investigations, and Agent Detection (telling people from AI agents on a website). Both entrances stay open: if you came from a resemble.ai page and still need it, add `agent_stay=1` to its URL.

## Start here

1. Get an API key from your user. They create it at https://app.resemble.ai/account/api, or it may already be set as `RESEMBLE_API_KEY`. Don't ask for their password or sign them up without asking. Never print the key or put it in a web page.
2. Connect to https://mcp.resemble.ai/mcp (Streamable HTTP) with `Authorization: Bearer <RESEMBLE_API_KEY>`. Claude Code: `claude mcp add --transport http resemble https://mcp.resemble.ai/mcp --header "Authorization: Bearer <RESEMBLE_API_KEY>"`
3. Pick the tool for the task below. Full descriptions and input schemas: https://mcp.resemble.ai/tools.json

## What your user wants, and what to call

- Check if audio, an image, or a video is a deepfake: `detect_deepfake(url)`. Report `label` with `score`; if still processing, `get_detection(uuid)`.
- Which AI platform made fake audio: `detect_deepfake(url, audio_source_tracing=true)` or `trace_audio_source(uuid)`.
- Check if writing was made by AI: `detect_ai_text(text)`. Needs 25+ words. Report `prediction` with `confidence`. The first call after idle can take minutes.
- Transcript, speakers, emotion: `analyze_media(url)`; follow-ups with `ask_about_detection(detect_uuid, query)`.
- Watermarks: `detect_watermark(url)`, `apply_watermark(url)`.
- Investigate a claim, ID, document, or news media: `list_detect_agents()`, then `run_detect_agent_investigation(preset_id, url)`.
- Are a website's visitors people or AI agents: `agent_detection_create_site(domain)`, then put the returned `snippet` in the site's <head>. Only the `pk_live_` publishable key goes in the page.
- How much traffic comes from agents: `agent_detection_get_analytics()`, `agent_detection_list_sessions()`, `agent_detection_get_session(session_id)`.
- Anything else on Resemble (voices, text to speech): look it up with the docs MCP at https://mcp.resemble.ai/sse (no key needed), then call https://app.resemble.ai/api/v2 with the same key.

## Rules

- Never call media real or fake, or text AI- or human-written, without a completed detection result. Report the label with its score (for text: prediction with its confidence), and say detection is probabilistic.
- Keep the API key on the server side. A web page only ever gets the site's publishable `pk_live_` key.
- Detect Agents investigate media. Agent Detection (tools prefixed `agent_detection_`) labels website visitors as people or agents. They are different products.

## Tools

- `detect_deepfake`: Detect whether media (audio, image, or video) at a public HTTPS URL is a     deepfake / AI-generated. Polls to completion and returns the verdict label,     confidence score, and full result. Optional flags add media intelligence,     audio source tracing, visualization, reverse image search (images),     out-of-distribution detection, and zero-retention (auto-delete media after     analysis). model_type: auto | image | talking_head.
- `get_detection`: Fetch a detection by UUID, polling until it completes (bounded). Use after     detect_deepfake when a long job exceeded its wait budget.
- `detect_ai_text`: Detect whether TEXT (an essay, email, post, review, comment, article) was     written by an AI language model. Needs at least 25 words: shorter text comes     back as prediction 'uncertain' with no model call - concatenate several     messages from the same author to reach the minimum. Returns prediction     ('ai' | 'human'), confidence (how sure the model is of that prediction; it     is NOT an AI probability, so 'human' at 0.95 means strongly human), and the     full result. Only the first ~400 words are read; chunk longer documents.     A result can take several minutes when the model is cold or jobs are     queued - if status is still 'processing' when the wait budget ends, resume     with get_text_detection(uuid). Detection is probabilistic, not proof of authorship.
- `get_text_detection`: Fetch a text detection by UUID, polling until it completes (bounded). Use     after detect_ai_text returned status 'processing' - typically a cold start.
- `analyze_media`: Analyze media for structured intelligence: transcription, translation,     language, speaker info, emotion, scene description, abnormalities, and     misinformation analysis. media_type: auto | audio | video | image.
- `ask_about_detection`: Ask a natural-language question about a COMPLETED detection (e.g. 'how     confident is the model that this is fake?'). Returns the grounded answer.
- `detect_watermark`: Check whether media at a public HTTPS URL carries a Resemble invisible     watermark (audio-first; per-channel verdict for audio).
- `apply_watermark`: Embed an invisible Resemble provenance watermark into media (audio-first)     and return the watermarked media URL. strength 0.0-1.0 (image/video only).
- `trace_audio_source`: Get the audio source-tracing report for a detection (which AI platform     generated the fake audio). Only available when detection ran with     audio_source_tracing and labeled the audio fake.
- `list_detect_agents`: List the managed Detect Agents — investigators that wrap detection in a     multi-step workflow ending in a written assessment. Returns each agent's     preset_id plus this team's run allowance (free_runs_remaining, entitled),     which is worth checking before starting a run.
- `run_detect_agent_investigation`: Run a managed Detect Agent investigation against media at a public HTTPS     URL and return its verdict. preset_id is one of: investigate_social_content,     review_insurance_claim, verify_breaking_news, verify_document,     verify_evidence, verify_id (confirm with list_detect_agents). query states     the investigation objective; check_urls adds URLs for the agent to check.
- `get_detect_agent_run`: Fetch a persisted Detect Agent investigation by run_id, including its full     event transcript. Use after run_detect_agent_investigation reported     timed_out, or to re-read an earlier investigation.
- `agent_detection_list_sites`: List this team's Agent Detection integrations. Agent Detection tells a     website whether each visitor is a person or an AI agent (for example a     personal assistant browsing on someone's behalf). Each integration is one     website, with the domains its publishable key works on and the one-line     script snippet to paste into the site's <head>.
- `agent_detection_create_site`: Create an Agent Detection integration for a website and return its     publishable key (pk_live_...) and the script snippet to install. domain is     the site's domain, e.g. example.com. If the team already has an integration     for that domain, the existing one is returned instead of a duplicate.
- `agent_detection_update_site`: Replace the list of domains an Agent Detection integration's publishable     key is valid on (for example to add a staging or www host), and optionally     rename it. domains replaces the whole list, so include every domain to keep;     at least one is required.
- `agent_detection_get_analytics`: Summarise who is visiting a website: people vs AI agents. Returns totals     (visits, decided, agents, people, agent_share, gated), counts per visitor     class (human, computer_use_agent, browser_automation, scripted_client), and     breakdowns by page, day, and network. Use this to show how much traffic     comes from agents and which pages they use, so the site can be made easier     for helpful agents and protected from harmful ones.
- `agent_detection_list_sessions`: List individual website visits, newest first, each with its verdict     (settled: human, agent, or null while still open), visitor_class,     p_person, the page, referrer, user agent, and duration. Same filters as     agent_detection_get_analytics plus a free-text search. per_page max 100.
- `agent_detection_get_session`: Get one website visit and the evidence behind its verdict: the feature     vector it was decided from, plain-language observations, and each model     read. When the visit was recorded, the raw event stream is available;     it is omitted unless include_events is true, and then capped at the first     200 events. The verdict is advisory: it comes from browser signals, which     a determined attacker can fake.

## Links

- Docs: https://docs.resemble.ai
- Source: https://github.com/resemble-ai/resemble-mcp