apify · TC-MO · Aug 24, 2026 · Aug 24, 2026 · Aug 24, 2026 · Aug 24, 2026
diff --git a/apify-docs-theme/src/config.js b/apify-docs-theme/src/config.js
@@ -202,9 +202,9 @@ const themeConfig = {
                 ],
             },
             {
-                label: 'MCP',
-                href: `${absoluteUrl}/integrations/mcp`,
-                activeBasePath: 'integrations/mcp',
+                label: 'Agent tools',
+                href: `${absoluteUrl}/agent-tools`,
+                activeBasePath: 'agent-tools',
                 position: 'right',
                 target: '_self',
                 rel: 'dofollow',

diff --git a/sources/platform/agent-tools/docs-for-agents.md b/sources/platform/agent-tools/docs-for-agents.md
@@ -0,0 +1,71 @@
+---
+title: Apify docs for AI agents
+sidebar_label: Docs for agents
+description: Read Apify documentation programmatically through Markdown endpoints, llms.txt indexes, and MCP tools, and find every agent-facing surface Apify runs.
+sidebar_position: 3
+slug: /agent-tools/docs-for-agents
+---
+
+Every page on `docs.apify.com` is available as Markdown, and several indexes exist so an agent can discover pages before it reads them. Point your agent at these instead of letting it work from training data, which goes stale between releases.
+
+## Read one page as Markdown
+
+Append `.md` to any documentation URL:
+
+```bash
+curl https://docs.apify.com/actors.md
+```
+
+Or request the same page with a content negotiation header:
+
+```bash
+curl -H "Accept: text/markdown" https://docs.apify.com/actors
+```
+
+Apify Store listings work the same way, which is the fastest path to an Actor's README and input schema:
+
+```bash
+curl https://apify.com/apify/rag-web-browser.md
+```
+
+## Site-wide indexes
+
+| Surface | URL | What it's for |
+| :--- | :--- | :--- |
+| Documentation index | [`docs.apify.com/llms.txt`](https://docs.apify.com/llms.txt) | A compact list of every documentation page, for discovery before a targeted fetch. |
+| Full documentation | [`docs.apify.com/llms-full.txt`](https://docs.apify.com/llms-full.txt) | The entire corpus in one file. Roughly 45 MB, so most agents can't load it whole. |
+
+:::caution Prefer targeted fetches
+
+`llms-full.txt` exceeds the context window of most agents. Use `llms.txt` to find the page you need, then fetch that page's `.md` URL. Reach for `llms-full.txt` only when you're building an index offline.
+
+:::
+
+## Search the docs through MCP
+
+The [Apify MCP server](/integrations/mcp) exposes two documentation tools, `search-apify-docs` and `fetch-apify-docs`. Both work without authentication, so an agent can read Apify documentation before the user has an account.
+
+Use them over raw HTTP fetches when your agent is already connected through MCP - search returns ranked matches rather than making the agent guess at URLs.
+
+## Other agent-facing surfaces
+
+Apify runs several entry points outside the documentation. Agents rarely find them unless something links there, so they're collected here:
+
+| Surface | What it does |
+| :--- | :--- |
+| [`apify.com/agents.md`](https://apify.com/agents.md) | Platform overview written for agents, served as Markdown. Also at [`apify.com/.well-known/agents.md`](https://apify.com/.well-known/agents.md). |
+| [Apify Agent General Interface](https://agi.apify.com) | The front door for agents that need to pay their own way: buy a prepaid, spend-capped API token through an agentic-payment protocol, then call `api.apify.com` with it. See [agentic payments](/integrations/x402). |
+| [MCP configurator](https://mcp.apify.com) | Generates a ready-to-paste MCP client configuration. |
+| [Apify Store](https://apify.com/store) | Actor catalog. Every listing has a `.md` equivalent. |
+
+## Choose the right surface
+
+- For a page you can already name, fetch its `.md` URL. Cheapest option in tokens and always current.
+- To find out which page covers a topic, use `search-apify-docs` over MCP, or `llms.txt` if the agent has no MCP connection.
+- For API specifics, read the [OpenAPI definition](https://docs.apify.com/api/openapi.json) rather than prose documentation.
+
+## Related resources
+
+- [Apify agent tools](/agent-tools) - how documentation access fits with MCP, plugins, and skills
+- [Apify MCP server](/integrations/mcp) - the documentation tools and everything else MCP exposes
+- [Agent quickstart](/get-started/agent-onboarding) - connect an agent and run an Actor
diff --git a/sources/platform/agent-tools/index.mdx b/sources/platform/agent-tools/index.mdx
@@ -0,0 +1,104 @@
+---
+title: Apify agent tools
+sidebar_label: Overview
+description: Connect an AI coding agent to Apify. Compare the MCP server, plugins, Agent Skills, and machine-readable docs, then pick the setup for your client.
+sidebar_position: 0
+slug: /agent-tools
+---
+
+import Card from '@site/src/components/Card';
+import CardGrid from '@site/src/components/CardGrid';
+
+AI agents reach Apify through a live connection over the [MCP server](/integrations/mcp), a one-step [plugin](/agent-tools/plugin) for supported clients, [Agent Skills](/agent-tools/skills) that carry procedural knowledge, and [machine-readable documentation](/agent-tools/docs-for-agents). These stack rather than compete, and most setups use more than one.
+
+If you want the shortest path from zero to a first Actor run, start with the [agent quickstart](/get-started/agent-onboarding).
+
+## Key concepts
+
+| Piece | What it is | Reach for it when |
+| :--- | :--- | :--- |
+| MCP server | A live connection between your agent and the Apify platform, exposing tools to search [Apify Store](https://apify.com/store), run Actors, and read datasets. | Your agent needs to act on Apify: find an Actor, run it, get structured data back. |
+| Plugin | A single install that bundles the MCP server, an `apify` routing agent, and Agent Skills for one specific client. | Your client is supported and you want the whole setup in one step. |
+| Agent Skills | Instructions your agent loads on demand when it needs Apify-specific procedural knowledge, such as building an Actor or routing a scraping request. | Your agent already connects to Apify and you want it to follow proven multi-step workflows. |
+| Client libraries and CLI | The [JavaScript](https://docs.apify.com/api/client/js) and [Python](https://docs.apify.com/api/client/python) clients, the [REST API](/api/v2), and the [Apify CLI](/cli). | You're writing application code or scripts rather than prompting an agent. |
+| Machine-readable docs | Every documentation page as Markdown, plus `llms.txt` indexes and MCP documentation tools. | Your agent needs to read Apify documentation accurately instead of guessing. |
+
+The MCP server gives an agent *capability*; Agent Skills give it *procedure*. An agent with MCP alone can call any tool but has to work out the sequence itself. An agent with skills follows a workflow Apify already validated. Skills are not a separate integration method; they layer on top of a connection you already have.
+
+## Choose a path
+
+- If your coding agent has a [plugin](/agent-tools/plugin), install that. It configures MCP and skills together, so there's nothing else to wire up.
+- For a chat client or an agent framework, connect the [MCP server](/integrations/mcp) directly. LangChain, CrewAI, the Vercel AI SDK, and other frameworks have their own guides under [AI integrations](/integrations/ai).
+- To call Apify from your own application code, use a [client library or the REST API](/get-started/agent-onboarding#choose-your-integration-method).
+
+<CardGrid>
+    <Card
+        title="Plugin"
+        desc="One install that bundles the MCP server, the apify routing agent, and Agent Skills."
+        to="/agent-tools/plugin"
+        imageUrl="/img/platform/integrations/emoji-pluggable.svg"
+        smallImage
+    />
+    <Card
+        title="Agent Skills"
+        desc="Procedural knowledge your agent loads on demand for Apify workflows."
+        to="/agent-tools/skills"
+        imageUrl="/img/platform/integrations/emoji-actor-to-actor.svg"
+        smallImage
+    />
+    <Card
+        title="Docs for agents"
+        desc="Markdown endpoints, llms.txt indexes, and every other machine-readable surface."
+        to="/agent-tools/docs-for-agents"
+        imageUrl="/img/platform/integrations/emoji-api.svg"
+        smallImage
+    />
+</CardGrid>
+
+## Pick your client
+
+Clients with a dedicated Apify plugin:
+
+| Client | Guide |
+| :--- | :--- |
+| Claude Code CLI | [Claude Code CLI integration](/integrations/claude-code-cli) |
+| Cursor | [Cursor integration](/integrations/cursor) |
+| GitHub Copilot | [GitHub Copilot integration](/integrations/github-copilot) |
+| Codex in the ChatGPT desktop app | [Codex app integration](/integrations/codex-app) |
+| Codex CLI | [Codex CLI integration](/integrations/codex-cli) |
+| OpenCode | [OpenCode integration](/integrations/opencode) |
+| OpenClaw | [OpenClaw integration](/integrations/openclaw) |
+| Qoder CLI | [Qoder CLI integration](/integrations/qoder-cli) |
+| Qoder IDE | [Qoder IDE integration](/integrations/qoder-ide) |
+| QoderWork | [QoderWork integration](/integrations/qoder-work) |
+| Hermes Agent | [Hermes Agent integration](/integrations/hermes-agent) |
+
+Clients that connect through the MCP server directly:
+
+| Client | Guide |
+| :--- | :--- |
+| Claude Desktop | [Claude Desktop integration](/integrations/claude-desktop) |
+| ChatGPT | [ChatGPT integration](/integrations/chatgpt) |
+| Manus | [Manus integration](/integrations/manus) |
+| Any other MCP-capable client | [Apify MCP server](/integrations/mcp) |
+
+:::tip Generate a client config
+
+The [MCP configurator](https://mcp.apify.com) produces a ready-to-paste configuration for most clients, including ones without a dedicated guide.
+
+:::
+
+## Build agents on Apify
+
+The pages above cover agents that *call* Apify. Three adjacent topics are easy to confuse with them:
+
+- [Develop AI agents on Apify](/actors/development/quick-start/develop-ai-agents) - build an agent that runs as an Actor on the platform, rather than connecting an external agent to it.
+- [MCP connectors](/integrations/mcp-connectors) - let an Actor you built act on a user's third-party accounts, such as Notion, Slack, or GitHub, without handling raw credentials.
+- [Agentic payments](/integrations/x402) - let an agent pay for Actor runs through the x402 protocol. The [Apify Agent General Interface](https://agi.apify.com) is the entry point for agents that need a prepaid, spend-capped API token.
+
+## Related resources
+
+- [Agent quickstart](/get-started/agent-onboarding) - run your first Actor from an agent
+- [Apify MCP server](/integrations/mcp) - full MCP reference, including tool selection and production practices
+- [AI integrations](/integrations/ai) - frameworks, vector databases, and every AI integration Apify supports
+- [Build Actors with AI](/actors/development/quick-start/build-with-ai) - use a coding agent to build an Actor
diff --git a/sources/platform/agent-tools/plugin.md b/sources/platform/agent-tools/plugin.md
@@ -0,0 +1,81 @@
+---
+title: Apify plugin for AI coding agents
+sidebar_label: Plugin
+description: Install the Apify plugin to give a coding agent the MCP server, the apify routing agent, and Agent Skills in one step. Compare coverage per client.
+sidebar_position: 1
+slug: /agent-tools/plugin
+---
+
+The Apify plugin is the shortest way to connect a coding agent to Apify: one install configures the MCP server and Agent Skills together, instead of setting each up separately.
+
+Apify maintains a plugin per client, because each client has its own plugin format and install flow. What the plugins bundle differs by client, so check [what your client gets](#coverage-by-client) before you start.
+
+## What a plugin bundles
+
+Most plugins bundle three things:
+
+- The [Apify MCP server](/integrations/mcp) (`https://mcp.apify.com`) for the live connection to the platform. Its configuration ships inside the plugin, so you never edit an MCP config file by hand.
+- An `apify` routing agent that picks the right tool or skill from a natural-language request, so you don't have to name tools yourself.
+- [Agent Skills](/agent-tools/skills) covering scraping, Actor development, actorization, output schemas, and SDK integration.
+
+## Coverage by client
+
+| Client | Plugin source | MCP server | Routing agent | Agent Skills |
+| :--- | :--- | :---: | :---: | :---: |
+| [Claude Code CLI](/integrations/claude-code-cli) | [`apify/apify-claude-code-plugin`](https://github.com/apify/apify-claude-code-plugin) | Yes | Yes | Yes |
+| [Cursor](/integrations/cursor) | [`apify/apify-cursor-plugin`](https://github.com/apify/apify-cursor-plugin) | Yes | Yes | Yes |
+| [GitHub Copilot](/integrations/github-copilot) | [`apify/apify-github-copilot-plugin`](https://github.com/apify/apify-github-copilot-plugin) | Yes | Yes | Yes |
+| [Codex in the ChatGPT desktop app](/integrations/codex-app) | [`apify/apify-codex-plugin`](https://github.com/apify/apify-codex-plugin) | Yes | No | Yes |
+| [Codex CLI](/integrations/codex-cli) | [`apify/apify-codex-plugin`](https://github.com/apify/apify-codex-plugin) | Yes | No | Yes |
+| [OpenCode](/integrations/opencode) | [`opencode-apify`](https://www.npmjs.com/package/opencode-apify) | Yes | No | No |
+| [OpenClaw](/integrations/openclaw) | `@apify/apify-openclaw-plugin` | Yes | No | No |
+| [Qoder CLI](/integrations/qoder-cli) | [`apify/apify-qoder-plugin`](https://github.com/apify/apify-qoder-plugin) | Yes | Yes | Yes |
+| [Qoder IDE](/integrations/qoder-ide) | [`apify/apify-qoder-plugin`](https://github.com/apify/apify-qoder-plugin) | Yes | Yes | Yes |
+| [QoderWork](/integrations/qoder-work) | [`apify/apify-qoder-plugin`](https://github.com/apify/apify-qoder-plugin) | Yes | Yes | Yes |
+| [Hermes Agent](/integrations/hermes-agent) | `apify-hermes-agent-plugin` | No | No | No |
+
+Hermes Agent is the exception to the pattern above. Its plugin doesn't carry the MCP server. It registers three dedicated tools instead - `apify_discover`, `apify_start`, and `apify_collect` - which the agent calls directly.
+
+If your client isn't listed, connect the [MCP server](/integrations/mcp) directly and install [Agent Skills](/agent-tools/skills) separately. The [MCP configurator](https://mcp.apify.com) generates a config for most clients.
+
+## Install
+
+Install flows differ per client. Some use a plugin marketplace, some a command palette, and some a single terminal command, so each has its own guide:
+
+- [Claude Code CLI](/integrations/claude-code-cli) - add the marketplace, then install from the **Discover** tab.
+- [Cursor](/integrations/cursor) - install from the Cursor plugin marketplace.
+- [GitHub Copilot](/integrations/github-copilot) - install from source through the VS Code command palette.
+- [Codex app](/integrations/codex-app) and [Codex CLI](/integrations/codex-cli) - add the marketplace with the `/plugins` command.
+- [OpenCode](/integrations/opencode) - `opencode plugin opencode-apify`.
+- [OpenClaw](/integrations/openclaw) - `openclaw plugins install @apify/apify-openclaw-plugin`.
+- [Qoder CLI](/integrations/qoder-cli), [Qoder IDE](/integrations/qoder-ide), and [QoderWork](/integrations/qoder-work) - install from the Qoder Marketplace.
+- [Hermes Agent](/integrations/hermes-agent) - `pip install apify-hermes-agent-plugin`, then `hermes plugins enable apify`.
+
+Every plugin needs authentication before it can run Actors. Read-only tools such as searching Apify Store and fetching Actor details work without signing in.
+
+:::tip Authenticate once
+
+Most clients authenticate through OAuth in a browser tab and keep the connection for future sessions. Revoke access anytime in [Apify Console > Settings > Integrations](https://console.apify.com/settings/integrations).
+
+:::
+
+## Plugin or the parts separately
+
+Installing the MCP server and Agent Skills yourself gives you roughly the same capability as the plugin, with two differences:
+
+- You maintain the MCP configuration and the skill versions yourself. Skills installed with `npx skills add` don't update on their own - reinstall them to pick up changes. A plugin updates as a unit.
+- You don't get the `apify` routing agent, so prompts have to name tools or skills more explicitly.
+
+Choose the separate route when your client has no plugin, when you need a narrower [tool selection](/integrations/mcp#tool-selection) than the plugin ships with, or when you're wiring Apify into an agent framework rather than a coding assistant.
+
+## Limitations
+
+- Long-running Actors can exceed the time a single tool call waits for completion. Reduce the scope or split the work across prompts.
+- Each Actor run consumes Apify platform usage on top of your agent's own usage. See [Billing](/account/billing).
+- Skills that edit files - Actor development, actorization, and SDK integration - make local changes. Review them before you commit or deploy.
+
+## Related resources
+
+- [Agent Skills](/agent-tools/skills) - what the bundled skills do and how to install them standalone
+- [Apify MCP server](/integrations/mcp) - tool reference, authentication, and production practices
+- [Apify agent tools](/agent-tools) - how plugins, MCP, and skills fit together