CanAgentUse MCP Server launch: scan and fix sites from your coding agent
CanAgentUse MCP Server lets coding agents run scans, read evidence, fetch Skill Markdown, authenticate with OAuth, and pull fix instructions from one remote endpoint.
Share
Website readiness work usually breaks at the handoff.
The scanner finds a failure. The report explains it. A coding agent can edit the repo. Then a developer still has to copy report fragments into a prompt, explain the context, paste a fix guide, and hope the agent changes the right file.
Today we are launching the CanAgentUse MCP Server, a remote Model Context Protocol server for coding agents. Codex, Claude Code, Cursor, VS Code, GitHub Copilot, Gemini, Goose, Qwen, Amp, OpenCode, and other MCP clients can use CanAgentUse scans and fix guidance without leaving the coding workflow.
The endpoint is:
Texthttps://canagentuse.com/api/mcp
The MCP Server product page has the full install guide, with setup paths for Codex, Claude, Cursor, Gemini, VS Code, Hermes, OpenClaw, GitHub Copilot, Qwen, Amp, Goose, and more.
TL;DR: CanAgentUse MCP Server lets a coding agent create a website scan, watch scan progress, read the completed report, list supported checks, fetch published Skill Markdown, and request report-specific fix instructions. It uses OAuth scopes for account access and exposes resources for tools, skills, OpenAPI, OAuth metadata, scopes, docs, and scan events.
What launched?
CanAgentUse MCP Server is a hosted MCP endpoint at https://canagentuse.com/api/mcp. You do not run a local stdio process for this product. Add the remote endpoint to an MCP client, approve CanAgentUse OAuth, then ask the agent to scan a URL and work from the report.
The server speaks MCP over HTTP and returns standard JSON-RPC responses. On initialization it advertises tools, prompts, and resource subscriptions. Scan event resources can send progress updates while a scan is running.
That means a coding agent can move through a practical loop:
- Create a scan for a public HTTP or HTTPS URL.
- Subscribe to scan progress or poll status.
- Read the completed report.
- Pick a failed or warning check that is fixable in the repo.
- Fetch the relevant remediation Skill Markdown.
- Request report-specific fix instructions for that exact failure.
- Patch the code.
- Run the scan again.
The current install UI and supported editor list live here: CanAgentUse MCP Server.
Why does this need MCP?
MCP matters because the agent needs more than a pasted summary. It needs tools, structured results, resources, prompts, and authorization boundaries.
Agent-readiness checks can fail for very different reasons. A missing llms.txt file is not the same problem as a broken OAuth protected-resource document. A weak aria-label is not the same problem as an invalid MCP server card. A schema issue may be a single JSON-LD field. A crawler policy issue may involve robots.txt, AI bot rules, and route-level response evidence.
Generic advice is too thin here.
CanAgentUse already stores the evidence: inspected URLs, failed criteria, check categories, report links, issue details, and remediation guidance. The MCP Server makes that evidence available where the agent is editing code.
The result is a smaller prompt:
TextUse CanAgentUse MCP to scan this preview URL, find the top fixable failure, call get_fix_instructions, patch the repo, and tell me how to verify it.
That is the point. A developer should not have to translate every report into a custom agent prompt.
What tools are available?
The MCP Server exposes a mix of OpenAPI-derived tools and CanAgentUse-specific extension tools. Clients should call tools/list for the current schema. These are the main tools.
| Tool | What it does | Typical scope |
|---|---|---|
get_profile | Reads the signed-in CanAgentUse profile. | profile:read |
create_scan | Creates an agent-readiness scan for an absolute HTTP(S) URL. | scans:write |
list_scans | Lists normal scans visible to the signed-in user. | scans:read |
get_scan | Reads scan status, queue state, progress, and report links. | scans:read |
get_scan_result | Returns a curated completed scan result with report evidence. | scans:read |
list_websites | Lists saved websites in the account. | website:read |
create_website | Adds a saved website and optional autoscan setting. | website:write |
get_website | Reads one saved website and related details. | website:read |
update_website | Updates website URL, label, or autoscan setting. | website:write |
list_website_scans | Lists scans for a saved website. | website:read |
list_skills | Lists published CanAgentUse Agent Skills. | OAuth access |
get_skill | Reads a published Skill Markdown guide by slug. | OAuth access |
list_checks | Lists supported checks with categories, goals, references, and skill paths. | OAuth access |
get_fix_guidance | Returns check metadata plus the linked remediation skill for a slug. | OAuth access, rate limited |
get_fix_instructions | Returns report-specific fix instructions for a failed or warning check. | Public report or scans:read, rate limited |
create_scan accepts a url and optional checks.include or checks.exclude selection. It rejects unsupported request fields and requires an absolute HTTP(S) URL.
get_scan_result is the tool most agents should use after a scan completes. It returns a curated report snapshot, so the agent does not have to scrape the human report page.
get_fix_instructions is the tool to use when the agent has a report ID and a skill slug. It combines criterion-level report evidence with the relevant remediation guidance, so the fix is tied to the actual failure instead of a general best-practice note.
What resources can the agent read?
MCP resources give the agent stable reference material without adding more chat text. CanAgentUse exposes service metadata, contracts, OAuth information, scopes, tool catalogs, and Skill Markdown as resources.
| Resource URI | What it contains |
|---|---|
can-agent-use://service | MCP endpoint, OpenAPI URL, OAuth URLs, documentation links, and result-flow URLs. |
can-agent-use://openapi | The OpenAPI contract used to derive MCP tools. |
can-agent-use://oauth | Protected-resource metadata, authorization-server metadata, authorize URL, token URL, JWKS URL, and scopes. |
can-agent-use://scopes | The canonical API scopes used by CanAgentUse MCP and API operations. |
can-agent-use://tools | The current MCP tool catalog. |
can-agent-use://skills | The published Agent Skills catalog. |
can-agent-use://skills/{slug} | One Skill Markdown guide. |
can-agent-use://scans/{scanId}/events | A subscribable scan progress resource. |
can-agent-use://docs | Agent-readable usage notes and public documentation pointers. |
This helps when the agent needs context before editing. It can read the check catalog, inspect the relevant Skill Markdown, then apply the report-specific instructions.
What prompts are built in?
The server also advertises MCP prompts for common workflows. They are optional, but they give MCP clients a cleaner starting point.
| Prompt | Use it when |
|---|---|
scan_website | You want the agent to create a scan and return the scan ID plus status/result/report URLs. |
inspect_scan_result | You already have a scan ID and want the agent to summarize readiness, top failures, and next fixes. |
manage_website_autoscan | You want the agent to inspect a saved website and change its autoscan setting. |
apply_agent_skill | You want the agent to fetch a published Skill Markdown guide and use it as the implementation guide. |
A typical workflow combines prompts and tools. Use scan_website to start the run, then get_scan_result, then get_fix_instructions for the first repo-fixable failure.
How OAuth and scopes work
CanAgentUse MCP uses OAuth for account access. When an MCP client connects without a valid OAuth token, the server returns authorization metadata for the CanAgentUse protected resource and authorization server.
The server publishes:
Texthttps://canagentuse.com/.well-known/oauth-protected-resource
https://canagentuse.com/.well-known/oauth-authorization-server
https://canagentuse.com/oauth/authorize
https://canagentuse.com/oauth/token
https://canagentuse.com/oauth/jwks.json
The canonical scopes are:
| Scope | Permission |
|---|---|
profile:read | Read profile name and email. |
scans:read | Read scan history and scan report details. |
scans:write | Create scans with selected checks. |
website:read | Read saved websites and their scan history. |
website:write | Add saved websites and update autoscan settings. |
The default authorization request asks for:
Textprofile:read scans:read scans:write website:read website:write
Private scans require the signed-in owner. Public reports can be used for report-specific fix instructions without broad account access. Private report reads still require scans:read for the owner.
What are the current limits?
The MCP Server is quota-aware. Limited tools return rate-limit metadata so a client can stop cleanly instead of retrying in a loop.
Current free-plan defaults include:
| Tool group | Default limit |
|---|---|
| MCP fix guidance | 20 requests per 60 minutes |
| Report-specific fix instructions | 20 requests per 60 minutes |
Other scan, saved-website, account, and private-report behavior follows the user's CanAgentUse plan and approved scopes. Teams that need heavier usage, private rollout support, or custom agent workflows can start from the MCP Server product page and contact us there.
How do you install it?
The product page has the maintained install guide for every supported editor: Install CanAgentUse MCP Server.
Codex
Add the remote server:
Terminalcodex mcp add can-agent-use --url https://canagentuse.com/api/mcp
Verify it appears in Codex:
Terminalcodex mcp list
Then authorize CanAgentUse when Codex asks for access.
Claude Code
Add the server over HTTP:
Terminalclaude mcp add --transport http can-agent-use https://canagentuse.com/api/mcp
Open the MCP menu in Claude Code, select can-agent-use, and complete authentication.
Text/mcp
Cursor
Cursor can install from a protocol link. Use the Cursor install button on the MCP Server product page, review the server details, then approve the CanAgentUse MCP config in Cursor.
Gemini
Add this MCP config:
JSON{
"mcpServers": {
"can-agent-use": {
"httpUrl": "https://canagentuse.com/api/mcp",
"timeout": 5000
}
}
}
Then authenticate:
Text/mcp auth can-agent-use
VS Code and GitHub Copilot
Try the installer button on the product page first. If the protocol link does not open VS Code, use the CLI:
Terminalcode --add-mcp '{"name":"can-agent-use","type":"http","url":"https://canagentuse.com/api/mcp"}'
If that is not available, create .vscode/mcp.json:
JSON{
"servers": {
"can-agent-use": {
"type": "http",
"url": "https://canagentuse.com/api/mcp"
}
}
}
Generic MCP client
For clients that accept remote MCP config, use the CanAgentUse endpoint as an HTTP or Streamable HTTP server:
YAMLname: can-agent-use
transport: streamable_http
url: https://canagentuse.com/api/mcp
Some clients use url, some use serverUrl, and some use httpUrl. Use the field your client expects. The product page keeps those variants in one place.
What should you ask your agent first?
Start with a page where the repo can realistically fix the problem: a product page, docs page, marketing page, app route, or preview deployment.
Use a prompt like:
TextUse CanAgentUse MCP to scan this URL: https://example.com.
When the scan finishes, read the result, identify the top three failures that are fixable in this repository, call get_fix_instructions for the first one, make the smallest safe code change, and explain how to verify it.
If the first run finds policy or product decisions, do not force the agent to guess. Ask it to separate code fixes from decisions a person should review.
Good first fixes tend to be concrete:
| Failure type | Why it is a good first MCP task |
|---|---|
| Missing metadata | The agent can add or adjust tags in one file. |
| Broken discovery links | The agent can update routes, headers, or well-known files. |
| Schema gaps | The agent can add JSON-LD that matches visible page content. |
| Weak accessibility names | The agent can label controls and rerun the scan. |
| Stale protocol URLs | The agent can update config and verify the new endpoint. |
| Thin tool descriptions | The agent can improve descriptions and check the catalog again. |
Harder tasks, such as bot policy, checkout behavior, account permissions, and legal text, should still include human review.
How this fits with CanAgentUse reports
The MCP Server does not replace the human report. It connects the report to the coding loop.
People still use the report to review score, categories, evidence, screenshots, and prioritization. Agents use MCP tools and resources to read the same evidence in a form they can act on.
That division matters. A human may decide that a low-scoring checkout path needs product review before code changes. An agent may still be able to fix an obvious schema typo, missing link header, inaccessible button, or wrong MCP metadata field immediately.
Use this workflow:
- Let the scan find the evidence.
- Let the agent fix bounded code issues.
- Let humans review policy and risk decisions.
- Run the scan again.
What is not included?
This launch is for the hosted CanAgentUse MCP Server at:
Texthttps://canagentuse.com/api/mcp
It is not a local stdio server you install from npm. It is not a replacement for your own MCP server. It does not grant broad account access without OAuth scopes. It does not bypass private report ownership. It does not execute arbitrary shell commands in your repo.
Your coding agent still edits code through its own environment. CanAgentUse supplies scan tools, resources, evidence, and remediation guidance.
Start here
Open the CanAgentUse MCP Server product page, pick your editor, and install the server.
Then give your agent one URL and one clear instruction:
TextScan this page with CanAgentUse MCP. Find one high-impact failure that can be fixed in this repo. Fetch the fix instructions, patch it, and rerun the scan.
That is the product: CanAgentUse provides the evidence, your coding agent makes the code change, and a fresh scan verifies the result.
Share