diff --git a/.claude/skills/README.md b/.claude/skills/README.md
index 8ef224946a..875432d2e0 100644
--- a/.claude/skills/README.md
+++ b/.claude/skills/README.md
@@ -16,6 +16,7 @@ A skill is a folder with a `SKILL.md` (the instructions) and sometimes `referenc
 | [`content-write-blog`](content-write-blog/SKILL.md) | Scaffold a new Prisma blog post (frontmatter + section stubs) | "Draft a blog post about connection pooling" |
 | [`content-create-hero-image`](content-create-hero-image/SKILL.md) | Generate a post's hero (SVG) and social/OG image (PNG) in the Eclipse house style | "Create a cover image for my Compute post" |
 | [`docs-writer`](docs-writer/README.md) | Write or rewrite developer docs (how-to, concept, reference) | "Write a how-to for deploying to Prisma Compute" |
+| [`docs-agent-ready`](docs-agent-ready/SKILL.md) | Hold the docs' agent-readiness invariants (llms.txt budgets, coverage, skill/MCP endpoints) when editing them | "Add a new docs section to llms.txt" |
 
 ---
 
diff --git a/.claude/skills/docs-agent-ready/SKILL.md b/.claude/skills/docs-agent-ready/SKILL.md
new file mode 100644
index 0000000000..3700c470a0
--- /dev/null
+++ b/.claude/skills/docs-agent-ready/SKILL.md
@@ -0,0 +1,58 @@
+---
+name: docs-agent-ready
+description: Use when adding a new docs section or product area, editing llms.ts / the llms.txt or llms/[...slug] / llms-full.txt routes / get-llm-text / skill.md / .well-known endpoints, or working on the "agent score", "llms.txt", or anything "agent-ready" in the docs and site apps. Explains the invariants the Mintlify agent-readiness audit measures and how to hold them.
+metadata:
+  author: Prisma
+  version: "2026.7.21"
+---
+
+# Docs agent-readiness
+
+Keep Prisma's docs machine-readable so the Mintlify **agent-score** audit does not silently regress as content is added. The score measures whether AI agents can discover and fetch the docs: a working `llms.txt` index, per-page Markdown, a discoverable skill, and MCP discovery. The guard `apps/docs/scripts/lint-agent-ready.ts` (run `pnpm --filter docs lint:agent-ready`) enforces the invariants below on every PR via `.github/workflows/links.yml`.
+
+## Invariants
+
+- **Root `llms.txt` < 50k bytes** (warn at 35k). It links to per-area section indexes, not every page.
+- **Each section index < 50k bytes** (warn at 40k). Over budget means split the section.
+- **Every page is reachable** — each `filterPagesForLLMsIndex` page appears in a section file or the root "Other pages" list. The guard asserts against the generated content, not just membership.
+- **Directives in HTML + Markdown** — every page's Markdown (`getLLMText`) starts with the hidden `llms.txt` directive blockquote; the HTML page keeps a hidden directive as its first child.
+- **HTML/Markdown parity** via `data-markdown-ignore` on human-only chrome so the Markdown mirrors the page.
+- **`llms-full.txt` excludes** legacy `/orm/v6` and the Accelerate/Optimize products (`getLLMsFullPages`).
+- **Skill + MCP endpoints live at BOTH roots**: `www.prisma.io` (apps/site) and `/docs` (apps/docs).
+
+## File map
+
+| Endpoint | Generated by |
+|---|---|
+| `/docs/llms.txt` | `apps/docs/src/app/llms.txt/route.ts` → `buildLLMsIndexContent` (llms.ts) |
+| `/docs/llms/<slug>.txt` | `apps/docs/src/app/llms/[...slug]/route.ts` → `buildLLMsSectionContent` (llms.ts) |
+| `/docs/llms-full.txt` | `apps/docs/src/app/llms-full.txt/route.ts` → `getLLMsFullPages` (llms.ts) + `getLLMText` |
+| `/docs/<page>.md` | `apps/docs/src/lib/get-llm-text.ts` (`getLLMText`) |
+| `/docs/skill.md` | `apps/docs/src/app/skill.md/route.ts` → `apps/docs/src/lib/agent-skill.ts` |
+| `/docs/.well-known/mcp[.json]` | `apps/docs/src/lib/mcp-discovery.ts` |
+| `/skill.md`, `/.well-known/agent-skills/*` | `apps/site/src/lib/agent-skills.ts` (`buildSkillMarkdown`) |
+| `/.well-known/mcp*` (site) | `apps/site/src/lib/agent-skills.ts` (`buildMcpDiscovery`, server cards) |
+
+The route handlers are thin wrappers: shared builders in `llms.ts` are the single source of truth, so the guard measures exactly what the routes serve.
+
+## Playbooks
+
+**(a) Adding a new docs area.** Add an entry to `llmsSections` in `apps/docs/src/lib/llms.ts` with `prefixes` (and `excludePrefixes` if a sub-tree belongs elsewhere). Run `pnpm --filter docs lint:agent-ready`. A **"Catch-all creep"** warning (> 25 pages in root "Other pages") means a new docs area needs its own section here.
+
+**(b) Section over budget.** When a section fails/warns on size, split it into two sections in `llmsSections` (narrower `prefixes`, or carve a sub-tree out with a new slug). Re-run the guard.
+
+**(c) Changing page chrome** in `apps/docs/src/app/(docs)/(default)/[[...slug]]/page.tsx`: keep the hidden `llms.txt` directive as the first child, and put `data-markdown-ignore` on any human-only chrome (banners, nav, badges) so it stays out of the Markdown.
+
+**(d) Changing the CLI workflow or MCP tools** in docs content: update the skill copy in `apps/site/src/lib/agent-skills.ts` AND `apps/docs/src/lib/agent-skill.ts` — they quote real commands and tool names. Keep them in sync with the Prisma Postgres quickstart and `content/docs/ai/tools/mcp-server.mdx`. The `commonQueries` links in `llms.ts` must point to existing pages (the guard fails on stale links).
+
+**(e) Verification.**
+
+```bash
+pnpm --filter docs lint:agent-ready       # all invariants + size table
+pnpm --filter docs types:check            # types
+curl -s https://www.prisma.io/docs/llms.txt | head
+curl -s https://www.prisma.io/docs/skill.md | head
+curl -s https://www.prisma.io/.well-known/mcp
+```
+
+The guard prints a size table with per-file headroom so reviewers see how close each file is to its budget.
diff --git a/.github/workflows/links.yml b/.github/workflows/links.yml
index 5d8deedc04..d963db4c8f 100644
--- a/.github/workflows/links.yml
+++ b/.github/workflows/links.yml
@@ -29,3 +29,6 @@ jobs:
 
       - name: Validate documentation links
         run: pnpm run lint:links
+
+      - name: Validate agent-readiness
+        run: pnpm --filter docs lint:agent-ready
diff --git a/apps/docs/package.json b/apps/docs/package.json
index d729cbe6a4..912cd98f51 100644
--- a/apps/docs/package.json
+++ b/apps/docs/package.json
@@ -14,6 +14,7 @@
     "types:check": "fumadocs-mdx && next typegen && tsc --noEmit",
     "postinstall": "fumadocs-mdx",
     "lint:links": "tsx ./scripts/lint-links.ts",
+    "lint:agent-ready": "tsx ./scripts/lint-agent-ready.ts",
     "lint:external-links": "tsx ./scripts/lint-external-links.ts",
     "lint:images": "tsx ./scripts/lint-images.ts",
     "lint:code": "tsx ./scripts/lint-code-blocks.ts",
diff --git a/apps/docs/scripts/lint-agent-ready.ts b/apps/docs/scripts/lint-agent-ready.ts
new file mode 100644
index 0000000000..a77fc4e970
--- /dev/null
+++ b/apps/docs/scripts/lint-agent-ready.ts
@@ -0,0 +1,464 @@
+/**
+ * Agent-readiness guard.
+ *
+ * Keeps the Mintlify agent-score setup from silently regressing as docs content
+ * is added. It runs the SAME shared builders the route handlers use
+ * (`buildLLMsIndexContent`, `buildLLMsSectionContent`, `getLLMsFullPages` in
+ * `@/lib/llms`) so it measures exactly what agents fetch in production — no dev
+ * server required. Follows the `lint-links.ts` pattern: register the fumadocs
+ * loader, then dynamically import `@/lib/*`.
+ *
+ * See `.claude/skills/docs-agent-ready/SKILL.md` for the invariants and playbooks.
+ */
+import { register } from "node:module";
+
+register("fumadocs-mdx/node/loader", import.meta.url);
+
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const { source } = await import("@/lib/source");
+const llms = await import("@/lib/llms");
+const { getLLMText } = await import("@/lib/get-llm-text");
+const { protectFencedCodeBlocks, protectInlineCode } = await import("@/lib/llm-markdown");
+const { withDocsBasePath } = await import("@/lib/urls");
+const { agentSkillMarkdown } = await import("@/lib/agent-skill");
+const { mcpDiscoveryDocument } = await import("@/lib/mcp-discovery");
+
+// Hardcode the production base URL. Byte budgets must be stable and match what
+// runs in production, so this must NOT read NEXT_PUBLIC_PRISMA_URL — otherwise the
+// budgets would vary by environment and the numbers would not match production.
+const baseUrl = "https://www.prisma.io";
+
+// Directory of this script (apps/docs/scripts); used for source-level guards.
+const scriptDir = dirname(fileURLToPath(import.meta.url));
+
+// Budgets. Agents commonly truncate large text feeds at ~100k chars; we hold a
+// 50k safety budget for any single file, with earlier warnings so a section can
+// be split before it becomes a hard failure.
+const ROOT_FAIL = 50_000;
+const ROOT_WARN = 35_000;
+const SECTION_FAIL = 50_000;
+const SECTION_WARN = 40_000;
+const CATCHALL_WARN = 25;
+
+const MCP_URL = "https://mcp.prisma.io/mcp";
+const DIRECTIVE_MARKER = "> For the complete Prisma documentation index";
+const REQUIRED_SKILL_KEYS = [
+  "name",
+  "description",
+  "license",
+  "compatibility",
+  "metadata",
+  "allowed-tools",
+];
+
+type Status = "pass" | "warn" | "fail";
+const results: { status: Status; name: string; message: string }[] = [];
+const pass = (name: string, message = "") => results.push({ status: "pass", name, message });
+const warn = (name: string, message: string) => results.push({ status: "warn", name, message });
+const fail = (name: string, message: string) => results.push({ status: "fail", name, message });
+
+const size = (content: string) => Buffer.byteLength(content, "utf8");
+const pageLink = (url: string) => `(${baseUrl}${withDocsBasePath(url)})`;
+
+/**
+ * Returns which required frontmatter keys are missing. Works both on a finished
+ * skill string (parses the block between the first pair of `---` lines) and, as
+ * a fallback, on raw TypeScript source where the frontmatter lives inside a
+ * template literal (keys still start at column 0).
+ */
+function missingFrontmatterKeys(text: string): string[] {
+  const fenced = text.match(/^---\n([\s\S]*?)\n---/m);
+  const block = fenced ? fenced[1] : text;
+  return REQUIRED_SKILL_KEYS.filter((key) => !new RegExp(`^${key}:`, "m").test(block));
+}
+
+const allPages = source.getPages();
+const indexPages = llms.filterPagesForLLMsIndex(allPages);
+const availableSections = llms.filterAvailableLLMsSections(llms.llmsSections, indexPages);
+
+// ── Check 1: root llms.txt size ──────────────────────────────────────────────
+const rootContent = llms.buildLLMsIndexContent(allPages, baseUrl);
+const rootSize = size(rootContent);
+if (rootSize >= ROOT_FAIL) {
+  fail("Root llms.txt size", `${rootSize} bytes >= ${ROOT_FAIL} budget`);
+} else if (rootSize >= ROOT_WARN) {
+  warn("Root llms.txt size", `${rootSize} bytes >= ${ROOT_WARN} warning threshold`);
+} else {
+  pass("Root llms.txt size", `${rootSize} bytes`);
+}
+
+// ── Check 2: per-section sizes ───────────────────────────────────────────────
+const sectionContents = new Map<string, string>();
+const sizeTable: { name: string; bytes: number; budget: number }[] = [
+  { name: "llms.txt (root)", bytes: rootSize, budget: ROOT_FAIL },
+];
+for (const section of llms.llmsSections) {
+  const content = llms.buildLLMsSectionContent(section, indexPages, baseUrl);
+  sectionContents.set(section.slug, content);
+  const bytes = size(content);
+  sizeTable.push({ name: `llms/${section.slug}.txt`, bytes, budget: SECTION_FAIL });
+  const splitHint = "split this section in llmsSections (apps/docs/src/lib/llms.ts)";
+  if (bytes >= SECTION_FAIL) {
+    fail(`Section ${section.slug} size`, `${bytes} bytes >= ${SECTION_FAIL}; ${splitHint}`);
+  } else if (bytes >= SECTION_WARN) {
+    warn(`Section ${section.slug} size`, `${bytes} bytes >= ${SECTION_WARN}; ${splitHint}`);
+  } else {
+    pass(`Section ${section.slug} size`, `${bytes} bytes`);
+  }
+}
+
+// ── Check 3: coverage ────────────────────────────────────────────────────────
+// Every index page must be reachable via a section file OR the root "Other
+// pages" list. Assert against the actual generated content (not just membership)
+// so a builder/route rewrite that drops links is caught.
+const haystack = [rootContent, ...sectionContents.values()].join("\n");
+const uncovered = indexPages.filter((page) => !haystack.includes(pageLink(page.url)));
+if (uncovered.length > 0) {
+  fail(
+    "Page coverage",
+    `${uncovered.length} page(s) not linked from any section or the root index:\n    ${uncovered
+      .map((p) => p.url)
+      .join("\n    ")}`,
+  );
+} else {
+  pass("Page coverage", `all ${indexPages.length} index pages reachable`);
+}
+
+// ── Check 4: catch-all creep ─────────────────────────────────────────────────
+const unmatched = llms.getUnmatchedLLMsPages(indexPages, availableSections);
+if (unmatched.length > CATCHALL_WARN) {
+  warn(
+    "Catch-all creep",
+    `${unmatched.length} pages fall into the root "Other pages" list (> ${CATCHALL_WARN}); add a dedicated section to llmsSections for the new docs area`,
+  );
+} else {
+  pass("Catch-all creep", `${unmatched.length} unmatched pages`);
+}
+
+// ── Check 5: markdown directive placement + description across ALL pages ──────
+// The per-page markdown must carry the llms.txt directive as a blockquote
+// IMMEDIATELY after the H1, so agents fetching any `.md` page get pointed at the
+// index. Assert positionally (H1 line, blank line, directive line) across every
+// index page — not a sample. getLLMText runs on preprocessed content, so this is
+// fast enough to cover the full set.
+const directiveFailures: string[] = [];
+const missingDescription: string[] = [];
+for (const page of indexPages) {
+  let text: string;
+  try {
+    // getLLMText calls page.data.getText("processed"); verified to work under the
+    // fumadocs loader used by this script (same loader as lint-links.ts).
+    text = await getLLMText(page);
+  } catch (error) {
+    directiveFailures.push(`${page.url} (getLLMText threw: ${String(error)})`);
+    continue;
+  }
+
+  const lines = text.split("\n");
+  const h1Index = lines.findIndex((line) => line.startsWith("# "));
+  // Format is `# Title\n\n> directive…`, so the directive sits two lines below H1.
+  if (h1Index === -1 || !(lines[h1Index + 2] ?? "").startsWith(DIRECTIVE_MARKER)) {
+    directiveFailures.push(page.url);
+  }
+
+  const description = page.data.description?.trim();
+  if (description && !text.includes(description)) {
+    missingDescription.push(page.url);
+  }
+}
+
+if (directiveFailures.length > 0) {
+  fail(
+    "Directive placement",
+    `${directiveFailures.length} of ${indexPages.length} page(s) missing the llms.txt directive immediately after the H1:\n    ${directiveFailures
+      .slice(0, 10)
+      .join("\n    ")}`,
+  );
+} else {
+  pass("Directive placement", `all ${indexPages.length} pages carry the directive after the H1`);
+}
+
+if (missingDescription.length > 0) {
+  warn(
+    "Description in markdown",
+    `${missingDescription.length} page(s) have a frontmatter description not present in their markdown:\n    ${missingDescription
+      .slice(0, 10)
+      .join("\n    ")}`,
+  );
+} else {
+  pass("Description in markdown", "all frontmatter descriptions present in markdown");
+}
+
+// ── Check 5b: HTML surface source guard ──────────────────────────────────────
+// The rendered HTML page carries the same directive via a hidden element.
+// Rendering React in this script is not worth it; instead guard at the source
+// level that the docs page component emits a hidden element referencing llms.txt
+// BEFORE it renders <DocsPage. This is a source-level guard, not a render test.
+const docsPagePath = join(
+  scriptDir,
+  "..",
+  "src",
+  "app",
+  "(docs)",
+  "(default)",
+  "[[...slug]]",
+  "page.tsx",
+);
+try {
+  const docsPageSource = readFileSync(docsPagePath, "utf8");
+  const docsPageRenderIndex = docsPageSource.indexOf("<DocsPage");
+  const llmsRefIndex = docsPageSource.indexOf("llms.txt");
+  if (docsPageRenderIndex === -1) {
+    fail("HTML directive source guard", `<DocsPage not found in ${docsPagePath}`);
+  } else if (llmsRefIndex === -1) {
+    fail("HTML directive source guard", `page.tsx does not reference llms.txt`);
+  } else if (llmsRefIndex >= docsPageRenderIndex) {
+    fail(
+      "HTML directive source guard",
+      "page.tsx references llms.txt only after <DocsPage; the hidden directive must precede it",
+    );
+  } else {
+    pass("HTML directive source guard", "hidden llms.txt directive precedes <DocsPage");
+  }
+} catch (error) {
+  fail("HTML directive source guard", `could not read ${docsPagePath}: ${String(error)}`);
+}
+
+// ── Check 6: common queries resolve to existing pages ────────────────────────
+// filterAvailableLLMsLinks drops internal links whose page is missing; a dropped
+// entry is a stale commonQueries link. External links are always kept.
+const staleQueries = llms.commonQueries.filter(
+  (query) => llms.filterAvailableLLMsLinks([query], allPages).length === 0,
+);
+if (staleQueries.length > 0) {
+  fail(
+    "Common queries resolve",
+    `${staleQueries.length} commonQueries href(s) do not resolve to an existing page:\n    ${staleQueries
+      .map((q) => q.href)
+      .join("\n    ")}`,
+  );
+} else {
+  pass("Common queries resolve", `all ${llms.commonQueries.length} links resolve`);
+}
+
+// ── Check 7: llms-full exclusions ────────────────────────────────────────────
+const fullPages = llms.getLLMsFullPages(allPages);
+const v6Leak = fullPages.filter((p) => p.url === "/orm/v6" || p.url.startsWith("/orm/v6/"));
+const productLeak = fullPages.filter(
+  (p) => p.url.startsWith("/accelerate") || p.url.startsWith("/optimize"),
+);
+if (fullPages.length === 0) {
+  fail("llms-full exclusions", "getLLMsFullPages returned 0 pages");
+} else if (v6Leak.length > 0 || productLeak.length > 0) {
+  fail(
+    "llms-full exclusions",
+    `excluded pages leaked into llms-full.txt: ${[...v6Leak, ...productLeak]
+      .map((p) => p.url)
+      .join(", ")}`,
+  );
+} else {
+  pass("llms-full exclusions", `${fullPages.length} pages, no v6/Accelerate/Optimize leakage`);
+}
+
+// ── Check 8: skill.md frontmatter (docs + site) ──────────────────────────────
+const docsSkillMissing = missingFrontmatterKeys(agentSkillMarkdown);
+if (docsSkillMissing.length > 0) {
+  fail("Docs skill frontmatter", `missing keys: ${docsSkillMissing.join(", ")}`);
+} else {
+  pass("Docs skill frontmatter", "all required keys present");
+}
+
+// The site skill is built at runtime from a template literal in agent-skills.ts,
+// whose `@/lib/url` import cannot resolve under the docs tsconfig. Read the raw
+// source and check the frontmatter keys directly (they sit at column 0 in the
+// template literal body).
+const siteSkillPath = join(scriptDir, "..", "..", "site", "src", "lib", "agent-skills.ts");
+try {
+  const siteSkillSource = readFileSync(siteSkillPath, "utf8");
+  const siteSkillMissing = missingFrontmatterKeys(siteSkillSource);
+  if (siteSkillMissing.length > 0) {
+    fail("Site skill frontmatter", `missing keys: ${siteSkillMissing.join(", ")}`);
+  } else {
+    pass("Site skill frontmatter", "all required keys present");
+  }
+} catch (error) {
+  fail("Site skill frontmatter", `could not read ${siteSkillPath}: ${String(error)}`);
+}
+
+// ── Check 9: MCP discovery documents (docs + site) ───────────────────────────
+// Field-level validation of both discovery payloads so a wrong URL, transport,
+// missing version, or empty authentication is caught — not just "an object
+// exists". The site payload is built from a template in agent-skills.ts whose
+// `@/lib/url` import cannot resolve under the docs tsconfig, so its static fields
+// are validated from raw source (same approach as check 8).
+const mcpErrors: string[] = [];
+
+// Widen the `as const` literal types to plain strings so the runtime comparisons
+// below are meaningful checks (not always-false literal-vs-literal comparisons).
+const docsMcp = mcpDiscoveryDocument as {
+  url: string;
+  transport: string;
+  version: string;
+  servers: readonly { name: string; url: string; transport: string; authentication: string }[];
+};
+if (docsMcp.url !== MCP_URL) {
+  mcpErrors.push(`docs: top-level url is "${docsMcp.url}", expected "${MCP_URL}"`);
+}
+if (docsMcp.transport !== "http") {
+  mcpErrors.push(`docs: transport is "${docsMcp.transport}", expected "http"`);
+}
+if (typeof docsMcp.version !== "string" || docsMcp.version.trim() === "") {
+  mcpErrors.push("docs: version is missing or empty");
+}
+if (!Array.isArray(docsMcp.servers) || docsMcp.servers.length === 0) {
+  mcpErrors.push("docs: servers array is missing or empty");
+} else {
+  docsMcp.servers.forEach((server, i) => {
+    if (server.url !== MCP_URL) {
+      mcpErrors.push(`docs: servers[${i}].url is "${server.url}", expected "${MCP_URL}"`);
+    }
+    if (server.transport !== "http") {
+      mcpErrors.push(`docs: servers[${i}].transport is "${server.transport}", expected "http"`);
+    }
+    if (typeof server.authentication !== "string" || server.authentication.trim() === "") {
+      mcpErrors.push(`docs: servers[${i}].authentication is missing or empty`);
+    }
+  });
+}
+
+try {
+  const siteSource = readFileSync(siteSkillPath, "utf8");
+  const urlMatch = siteSource.match(/const MCP_SERVER_URL\s*=\s*"([^"]+)"/);
+  if (!urlMatch) {
+    mcpErrors.push("site: could not find the MCP_SERVER_URL constant");
+  } else if (urlMatch[1] !== MCP_URL) {
+    mcpErrors.push(`site: MCP_SERVER_URL is "${urlMatch[1]}", expected "${MCP_URL}"`);
+  }
+
+  // Validate the static fields of the buildMcpDiscovery() payload from source.
+  const discoveryMatch = siteSource.match(
+    /export function buildMcpDiscovery\([^)]*\)\s*\{([\s\S]*?)\n\}/,
+  );
+  const discoveryBody = discoveryMatch?.[1];
+  if (!discoveryBody) {
+    mcpErrors.push("site: could not find the buildMcpDiscovery() function");
+  } else {
+    if (!/\btransport:\s*"http"/.test(discoveryBody)) {
+      mcpErrors.push('site: buildMcpDiscovery transport is not "http"');
+    }
+    if (!/\burl:\s*MCP_SERVER_URL\b/.test(discoveryBody)) {
+      mcpErrors.push("site: buildMcpDiscovery url is not MCP_SERVER_URL");
+    }
+    if (!/\bauthentication:\s*"[^"]+"/.test(discoveryBody)) {
+      mcpErrors.push("site: buildMcpDiscovery server authentication is missing or empty");
+    }
+  }
+} catch (error) {
+  mcpErrors.push(`site: could not read ${siteSkillPath}: ${String(error)}`);
+}
+
+if (mcpErrors.length > 0) {
+  fail("MCP discovery", `field validation failed:\n    ${mcpErrors.join("\n    ")}`);
+} else {
+  pass(
+    "MCP discovery",
+    `docs + site valid: url "${MCP_URL}", transport http, ${docsMcp.servers.length} server(s)`,
+  );
+}
+
+// ── Check 10: placeholder protectors are collision-safe ──────────────────────
+// Regression coverage for the protect/restore pipeline shared by llm-markdown.ts
+// and get-llm-text.ts. Adversarial inputs embed text that LOOKS like the internal
+// placeholders inside inline code and fenced blocks, plus a normal body link. A
+// correct implementation restores every input byte-for-byte and rewrites ONLY the
+// body links that sit outside code. This guards against the old sequential-replace
+// corruption (a protected span reintroducing a later token; the fenced restore
+// consuming a sentinel reintroduced by an inline span).
+{
+  // Mirror absolutizeInBodyLinks exactly: fences first, then inline spans, rewrite
+  // the body links in between, then restore inline then fences.
+  const runPipeline = (markdown: string) => {
+    const fences = protectFencedCodeBlocks(markdown);
+    const inline = protectInlineCode(fences.markdown);
+    const rewritten = inline.markdown.replace(/\]\((\/[^)\s]*)\)/g, (full, target: string) => {
+      if (target.startsWith("//")) return full;
+      return `](https://www.prisma.io${target})`;
+    });
+    return fences.restore(inline.restore(rewritten));
+  };
+
+  const fence = "```";
+  const cases: { name: string; input: string; expected: string }[] = [
+    {
+      name: "inline code containing old-format placeholder text is preserved",
+      input: "Use `__LLM_INLINE_CODE_1__` and `__LLM_FENCED_CODE_BLOCK_0__` literally here.",
+      expected: "Use `__LLM_INLINE_CODE_1__` and `__LLM_FENCED_CODE_BLOCK_0__` literally here.",
+    },
+    {
+      name: "fenced block containing inline-sentinel-looking text + body link is preserved",
+      input: `${fence}\n__LLM_INLINE_CODE_0__ and [x](/orm/a)\n${fence}`,
+      expected: `${fence}\n__LLM_INLINE_CODE_0__ and [x](/orm/a)\n${fence}`,
+    },
+    {
+      name: "link inside inline code is NOT rewritten",
+      input: "See `[label](/orm/foo)` inline.",
+      expected: "See `[label](/orm/foo)` inline.",
+    },
+    {
+      name: "body link outside code IS rewritten",
+      input: "See [label](/orm/foo) here.",
+      expected: "See [label](https://www.prisma.io/orm/foo) here.",
+    },
+    {
+      name: "mixed: body link rewrites while placeholder-looking code stays verbatim",
+      input: `Body [a](/x) then \`__LLM_FENCED_CODE_BLOCK_0__\` then\n${fence}\ncode [b](/y)\n${fence}\nend.`,
+      expected: `Body [a](https://www.prisma.io/x) then \`__LLM_FENCED_CODE_BLOCK_0__\` then\n${fence}\ncode [b](/y)\n${fence}\nend.`,
+    },
+  ];
+
+  const protectorFailures = cases.flatMap((testCase) => {
+    const actual = runPipeline(testCase.input);
+    if (actual === testCase.expected) return [];
+    return [
+      `${testCase.name}\n      expected: ${JSON.stringify(testCase.expected)}\n      actual:   ${JSON.stringify(actual)}`,
+    ];
+  });
+
+  if (protectorFailures.length > 0) {
+    fail(
+      "Protector round-trip",
+      `${protectorFailures.length} of ${cases.length} case(s) failed:\n    ${protectorFailures.join("\n    ")}`,
+    );
+  } else {
+    pass("Protector round-trip", `all ${cases.length} adversarial protect/restore cases pass`);
+  }
+}
+
+// ── Report ───────────────────────────────────────────────────────────────────
+const icon: Record<Status, string> = { pass: "✓", warn: "⚠", fail: "✗" };
+console.log("\nAgent-readiness checks\n");
+for (const result of results) {
+  const line = `${icon[result.status]} ${result.name}`;
+  console.log(result.message ? `${line} — ${result.message}` : line);
+}
+
+console.log("\nSize budget (bytes)\n");
+const nameWidth = Math.max(...sizeTable.map((row) => row.name.length));
+for (const row of sizeTable) {
+  const headroom = row.budget - row.bytes;
+  const flag = row.bytes >= row.budget ? " OVER" : "";
+  console.log(
+    `  ${row.name.padEnd(nameWidth)}  ${String(row.bytes).padStart(7)} / ${row.budget}  (${headroom >= 0 ? "+" : ""}${headroom} headroom)${flag}`,
+  );
+}
+
+const failures = results.filter((r) => r.status === "fail").length;
+const warnings = results.filter((r) => r.status === "warn").length;
+console.log(`\n${failures} failure(s), ${warnings} warning(s)\n`);
+
+if (failures > 0) {
+  process.exit(1);
+}
diff --git a/apps/docs/src/app/(docs)/(default)/[[...slug]]/page.tsx b/apps/docs/src/app/(docs)/(default)/[[...slug]]/page.tsx
index d2aab1eb24..2755ccbaa3 100644
--- a/apps/docs/src/app/(docs)/(default)/[[...slug]]/page.tsx
+++ b/apps/docs/src/app/(docs)/(default)/[[...slug]]/page.tsx
@@ -31,8 +31,29 @@ export default async function Page({ params }: { params: Promise<PageParams> })
   const aiPromptSlug = (page.data as { aiPrompt?: string }).aiPrompt;
   const promptContent = aiPromptSlug ? await getPromptContent(aiPromptSlug) : null;
 
+  const pageMarkdownUrl = `https://www.prisma.io${withDocsBasePath(page.url)}.md`;
+
   return (
     <>
+      <div
+        data-markdown-ignore
+        style={{
+          position: "absolute",
+          width: 1,
+          height: 1,
+          padding: 0,
+          margin: -1,
+          overflow: "hidden",
+          clip: "rect(0, 0, 0, 0)",
+          whiteSpace: "nowrap",
+          border: 0,
+        }}
+      >
+        For the complete Prisma documentation index optimized for AI agents, see{" "}
+        <a href="https://www.prisma.io/docs/llms.txt">https://www.prisma.io/docs/llms.txt</a>. A
+        markdown version of this page is available at{" "}
+        <a href={pageMarkdownUrl}>{pageMarkdownUrl}</a> (append <code>.md</code> to any docs URL).
+      </div>
       <TechArticleSchema page={page} />
       <BreadcrumbSchema page={page} />
       <DocsPage
@@ -44,7 +65,7 @@ export default async function Page({ params }: { params: Promise<PageParams> })
       >
         <div className="flex flex-col md:flex-row items-start gap-4 pt-2 pb-1 md:justify-between">
           <DocsTitle>{page.data.title}</DocsTitle>
-          <div className="flex flex-row gap-2 items-center">
+          <div className="flex flex-row gap-2 items-center" data-markdown-ignore>
             {promptContent && <CopyPromptButton fullPrompt={promptContent.fullPrompt} />}
             {!page.url.startsWith("/management-api/endpoints") && (
               <LLMCopyButton markdownUrl={`${withDocsBasePath(page.url)}.mdx`} />
@@ -64,7 +85,10 @@ export default async function Page({ params }: { params: Promise<PageParams> })
             })}
           />
         </DocsBody>
-        <div className="flex flex-row flex-wrap items-center justify-between gap-4 border-t pt-6 text-sm">
+        <div
+          className="flex flex-row flex-wrap items-center justify-between gap-4 border-t pt-6 text-sm"
+          data-markdown-ignore
+        >
           <EditOnGitHub
             href={`https://github.com/prisma/docs/edit/main/apps/docs/content/docs/${page.path}`}
           />
diff --git a/apps/docs/src/app/.well-known/mcp.json/route.ts b/apps/docs/src/app/.well-known/mcp.json/route.ts
new file mode 100644
index 0000000000..fa2d59ee7d
--- /dev/null
+++ b/apps/docs/src/app/.well-known/mcp.json/route.ts
@@ -0,0 +1,7 @@
+import { mcpDiscoveryResponse } from "@/lib/mcp-discovery";
+
+export const revalidate = false;
+
+export function GET() {
+  return mcpDiscoveryResponse();
+}
diff --git a/apps/docs/src/app/.well-known/mcp/route.ts b/apps/docs/src/app/.well-known/mcp/route.ts
new file mode 100644
index 0000000000..fa2d59ee7d
--- /dev/null
+++ b/apps/docs/src/app/.well-known/mcp/route.ts
@@ -0,0 +1,7 @@
+import { mcpDiscoveryResponse } from "@/lib/mcp-discovery";
+
+export const revalidate = false;
+
+export function GET() {
+  return mcpDiscoveryResponse();
+}
diff --git a/apps/docs/src/app/llms-full.txt/route.ts b/apps/docs/src/app/llms-full.txt/route.ts
index e9b4211102..117ab22ca4 100644
--- a/apps/docs/src/app/llms-full.txt/route.ts
+++ b/apps/docs/src/app/llms-full.txt/route.ts
@@ -1,18 +1,26 @@
 import { source } from "@/lib/source";
 import { getLLMText } from "@/lib/get-llm-text";
-import { createLLMsFullResponse } from "@/lib/llms";
+import { createLLMsFullResponse, getLLMsFullPages } from "@/lib/llms";
+import { getBaseUrl, withDocsBasePath } from "@/lib/urls";
 
 export const revalidate = false;
 
 export async function GET() {
+  const baseUrl = getBaseUrl();
+  const llmsTxtUrl = `${baseUrl}${withDocsBasePath("/llms.txt")}`;
+
   const description = `# Prisma Documentation - Full Content Feed
 
-This file contains the complete Prisma documentation in machine-readable format.
-Includes the current docs plus legacy v6 ORM pages.
+This file contains the current Prisma documentation in machine-readable format.
+Legacy Prisma ORM v6 content is not included here; fetch any v6 page directly by
+appending \`.md\` to its URL (for example, ${baseUrl}${withDocsBasePath("/orm/v6/...")}.md).
+For the documentation index, see ${llmsTxtUrl}.
 
 ---
 
 `;
 
-  return createLLMsFullResponse(description, source.getPages(), getLLMText);
+  const pages = getLLMsFullPages(source.getPages());
+
+  return createLLMsFullResponse(description, pages, getLLMText);
 }
diff --git a/apps/docs/src/app/llms.txt/route.ts b/apps/docs/src/app/llms.txt/route.ts
index 89dd9329a3..bc1a27456a 100644
--- a/apps/docs/src/app/llms.txt/route.ts
+++ b/apps/docs/src/app/llms.txt/route.ts
@@ -1,61 +1,11 @@
-import { getPageTitleText } from "@/lib/page-title";
 import { source } from "@/lib/source";
-import { getBaseUrl, withDocsBasePath } from "@/lib/urls";
-import {
-  commonQueries,
-  filterAvailableLLMsLinks,
-  filterAvailableLLMsSections,
-  filterPagesForLLMsIndex,
-  formatLLMsLink,
-  formatLLMsPageLink,
-  formatLLMsSectionLink,
-  llmsSections,
-} from "@/lib/llms";
+import { getBaseUrl } from "@/lib/urls";
+import { buildLLMsIndexContent } from "@/lib/llms";
 
 export const revalidate = false;
 
 export async function GET() {
-  const baseUrl = getBaseUrl();
-  const latestPages = filterPagesForLLMsIndex(source.getPages()).sort((a, b) =>
-    getPageTitleText(a.data.title, a.url).localeCompare(getPageTitleText(b.data.title, b.url)),
-  );
-
-  const commonQueriesList = filterAvailableLLMsLinks(commonQueries, latestPages)
-    .map((link) => formatLLMsLink(link, baseUrl))
-    .join("\n");
-  const subIndexList = filterAvailableLLMsSections(llmsSections, latestPages)
-    .map((section) => formatLLMsSectionLink(section, baseUrl))
-    .join("\n");
-  const latestDocsList = latestPages.map((page) => formatLLMsPageLink(page, baseUrl)).join("\n");
-
-  const content = `# Prisma Documentation
-
-> **Prisma changes frequently — verify against the changelog and current docs before implementing.**
-> Do not rely on training data for Prisma features. APIs, configuration, and conventions can change between versions.
->
-> First, fetch https://www.prisma.io/changelog.md to check for recent or relevant breaking changes,
-> then look up the relevant topic in the documentation below.
-
-> This documentation covers the current docs plus legacy v6 pages.
-> Prefer the Latest ORM section for current recommendations.
-> v6 pages are maintained for backwards compatibility only.
-
-## Common Queries
-
-${commonQueriesList}
-
-## Product Area Indexes
-
-${subIndexList}
-
-## Latest
-
-${latestDocsList}
-
-## Options
-
-- [Full documentation with content](${baseUrl}${withDocsBasePath("/llms-full.txt")})
-`;
+  const content = buildLLMsIndexContent(source.getPages(), getBaseUrl());
 
   return new Response(content, {
     headers: {
diff --git a/apps/docs/src/app/llms/[...slug]/route.ts b/apps/docs/src/app/llms/[...slug]/route.ts
index 1c5a2c5b3b..fc758cb129 100644
--- a/apps/docs/src/app/llms/[...slug]/route.ts
+++ b/apps/docs/src/app/llms/[...slug]/route.ts
@@ -1,12 +1,10 @@
 import {
+  buildLLMsSectionContent,
   filterAvailableLLMsSections,
   filterPagesForLLMsIndex,
-  filterPagesForLLMsSection,
-  formatLLMsPageLink,
   getLLMsSection,
   llmsSections,
 } from "@/lib/llms";
-import { getPageTitleText } from "@/lib/page-title";
 import { source } from "@/lib/source";
 import { getBaseUrl } from "@/lib/urls";
 import { notFound } from "next/navigation";
@@ -24,20 +22,7 @@ export async function GET(_req: Request, { params }: RouteContext<"/llms/[...slu
   const section = getLLMsSection(parseSectionSlug(slug), sourcePages);
   if (!section) notFound();
 
-  const baseUrl = getBaseUrl();
-  const pages = filterPagesForLLMsSection(sourcePages, section).sort((a, b) =>
-    getPageTitleText(a.data.title, a.url).localeCompare(getPageTitleText(b.data.title, b.url)),
-  );
-  const docsList =
-    pages.map((page) => formatLLMsPageLink(page, baseUrl)).join("\n") ||
-    "_No pages currently match this section._";
-
-  const content = `# Prisma Documentation - ${section.title}
-
-> ${section.description}
-
-${docsList}
-`;
+  const content = buildLLMsSectionContent(section, sourcePages, getBaseUrl());
 
   return new Response(content, {
     headers: {
diff --git a/apps/docs/src/app/skill.md/route.ts b/apps/docs/src/app/skill.md/route.ts
new file mode 100644
index 0000000000..f5949379fc
--- /dev/null
+++ b/apps/docs/src/app/skill.md/route.ts
@@ -0,0 +1,11 @@
+import { agentSkillMarkdown } from "@/lib/agent-skill";
+
+export const revalidate = false;
+
+export async function GET() {
+  return new Response(agentSkillMarkdown, {
+    headers: {
+      "Content-Type": "text/markdown; charset=utf-8",
+    },
+  });
+}
diff --git a/apps/docs/src/lib/agent-skill.ts b/apps/docs/src/lib/agent-skill.ts
new file mode 100644
index 0000000000..bf82944c06
--- /dev/null
+++ b/apps/docs/src/lib/agent-skill.ts
@@ -0,0 +1,171 @@
+/**
+ * The Prisma agent skill served by the docs app at /docs/skill.md.
+ * Kept in a lib module so the agent-readiness guard can import and validate it
+ * without importing the route handler. Keep the workflow commands in sync with
+ * the Prisma Postgres quickstart and content/docs/ai/tools/mcp-server.mdx.
+ */
+export const agentSkillMarkdown = `---
+name: prisma
+description: Set up and use Prisma ORM with Prisma Postgres — define a schema, run migrations, generate Prisma Client, and query a PostgreSQL database in TypeScript. Includes the remote Prisma MCP server for managing Prisma Postgres databases.
+license: Apache-2.0
+compatibility: Node.js and TypeScript projects using Prisma ORM (Prisma Client) and Prisma Postgres.
+metadata:
+  product: Prisma ORM + Prisma Postgres
+  version: "7"
+  documentation: https://www.prisma.io/docs
+  llms_txt: https://www.prisma.io/docs/llms.txt
+allowed-tools:
+  - Bash
+  - Read
+  - Edit
+  - Write
+---
+
+# Prisma
+
+Prisma is a next-generation TypeScript ORM and a managed PostgreSQL database:
+
+- **Prisma ORM** — a type-safe database toolkit. You define your data model in a Prisma Schema, Prisma Migrate turns it into SQL migrations, and Prisma Client gives you a fully typed query API.
+- **Prisma Postgres** — a fully managed PostgreSQL database that scales to zero and integrates with Prisma ORM and Prisma Studio.
+
+Prisma changes between versions. Before implementing a feature, verify against the current docs at https://www.prisma.io/docs and the changelog at https://www.prisma.io/changelog.md. Do not rely on training data for Prisma APIs, configuration, or conventions.
+
+## Golden workflow
+
+These are the core commands for a new TypeScript project (copied from the Prisma Postgres quickstart). Run the CLI with \`npx\`:
+
+1. **Initialize the project and install dependencies**
+
+   \`\`\`bash
+   npm init -y
+   npm install typescript tsx @types/node --save-dev
+   npx tsc --init
+   npm install prisma @types/pg --save-dev
+   npm install @prisma/client @prisma/adapter-pg pg dotenv
+   \`\`\`
+
+2. **Configure ESM support.** Update \`tsconfig.json\`:
+
+   \`\`\`json
+   {
+     "compilerOptions": {
+       "module": "ESNext",
+       "moduleResolution": "bundler",
+       "target": "ES2023",
+       "strict": true,
+       "esModuleInterop": true,
+       "ignoreDeprecations": "6.0"
+     }
+   }
+   \`\`\`
+
+   Then enable ESM in \`package.json\`:
+
+   \`\`\`json
+   {
+     "type": "module"
+   }
+   \`\`\`
+
+3. **Scaffold Prisma ORM.** This creates \`prisma/schema.prisma\`, a \`.env\` with \`DATABASE_URL\`, and \`prisma.config.ts\`:
+
+   \`\`\`bash
+   npx prisma init --output ../generated/prisma
+   \`\`\`
+
+4. **Provision a Prisma Postgres database.** Ask the user for approval before provisioning a hosted Prisma Postgres database — \`npx create-db\` creates a cloud resource. After approval, run it and replace \`DATABASE_URL\` in \`.env\` with the \`postgres://...\` connection string from the CLI output:
+
+   \`\`\`bash
+   npx create-db
+   \`\`\`
+
+5. **Define your data model** in \`prisma/schema.prisma\`, for example:
+
+   \`\`\`prisma
+   generator client {
+     provider = "prisma-client"
+     output   = "../generated/prisma"
+   }
+
+   datasource db {
+     provider = "postgresql"
+   }
+
+   model User {
+     id    Int     @id @default(autoincrement())
+     email String  @unique
+     name  String?
+     posts Post[]
+   }
+
+   model Post {
+     id        Int     @id @default(autoincrement())
+     title     String
+     content   String?
+     published Boolean @default(false)
+     author    User    @relation(fields: [authorId], references: [id])
+     authorId  Int
+   }
+   \`\`\`
+
+6. **Create and apply a migration**, then **generate Prisma Client**:
+
+   \`\`\`bash
+   npx prisma migrate dev --name init
+   npx prisma generate
+   \`\`\`
+
+7. **Instantiate Prisma Client** with the driver adapter and query your database:
+
+   \`\`\`typescript
+   import "dotenv/config";
+   import { PrismaPg } from "@prisma/adapter-pg";
+   import { PrismaClient } from "../generated/prisma/client";
+
+   const connectionString = \`\${process.env.DATABASE_URL}\`;
+   const adapter = new PrismaPg({ connectionString });
+   const prisma = new PrismaClient({ adapter });
+
+   const user = await prisma.user.create({
+     data: { name: "Alice", email: "alice@prisma.io" },
+   });
+   const users = await prisma.user.findMany({ include: { posts: true } });
+   \`\`\`
+
+8. **Explore your data** visually with Prisma Studio:
+
+   \`\`\`bash
+   npx prisma studio
+   \`\`\`
+
+When you change your schema later, re-run \`npx prisma migrate dev\` to create a new migration and \`npx prisma generate\` to update Prisma Client.
+
+### Safety with destructive commands
+
+Prisma ORM detects when it is invoked by AI coding agents and blocks destructive commands such as \`prisma migrate reset --force\`. Do not bypass this guardrail: stop, tell the user exactly which command you want to run and that it irreversibly destroys all data, and proceed only after explicit user consent.
+
+## Prisma MCP server
+
+Prisma provides a remote MCP server that lets AI tools manage Prisma Postgres databases (create databases, connection strings, and backups; run and introspect SQL) and search the Prisma documentation. It authenticates with Prisma Console via OAuth on first use.
+
+Add it with the standard MCP configuration:
+
+\`\`\`json
+{
+  "mcpServers": {
+    "Prisma": {
+      "url": "https://mcp.prisma.io/mcp"
+    }
+  }
+}
+\`\`\`
+
+The server exposes a \`search_prisma_documentation\` tool that returns cited answers grounded in the official Prisma docs — prefer it over training data for Prisma questions.
+
+## Documentation for agents
+
+- **Index:** https://www.prisma.io/docs/llms.txt — links to per-area indexes (Prisma ORM, Prisma Postgres, Guides, CLI, Studio, Platform, and more).
+- **Full content feed:** https://www.prisma.io/docs/llms-full.txt — the current docs as a single machine-readable file.
+- **Any page as Markdown:** append \`.md\` to any docs URL, e.g. https://www.prisma.io/docs/orm/prisma-client.md.
+- **Changelog:** https://www.prisma.io/changelog.md — check before implementing to catch breaking changes.
+`;
diff --git a/apps/docs/src/lib/get-llm-text.ts b/apps/docs/src/lib/get-llm-text.ts
index 0a5ea9eef2..fa785739d9 100644
--- a/apps/docs/src/lib/get-llm-text.ts
+++ b/apps/docs/src/lib/get-llm-text.ts
@@ -1,5 +1,9 @@
 import { source } from "@/lib/source";
-import { normalizeProcessedMarkdown } from "@/lib/llm-markdown";
+import {
+  normalizeProcessedMarkdown,
+  protectFencedCodeBlocks,
+  protectInlineCode,
+} from "@/lib/llm-markdown";
 import { getPageTitleText } from "@/lib/page-title";
 import { getBaseUrl, withDocsBasePath } from "@/lib/urls";
 import type { InferPageType } from "fumadocs-core/source";
@@ -173,10 +177,57 @@ function formatRelatedPages(relatedPages: RelatedPageLink[]) {
   return `\n\n## Related pages\n\n${links}`;
 }
 
+/**
+ * Rewrites in-body markdown links so the full feed and per-page markdown resolve
+ * correctly when read outside the app. Root-relative links (`/orm/...`) do not
+ * carry the `/docs` base path in the processed markdown, so an agent resolving
+ * them against the feed URL would drop `/docs`. We resolve each link against the
+ * docs source: known docs pages become absolute `<baseUrl>/docs/...` URLs, while
+ * links that are not docs pages (e.g. `/pricing`) become site-root URLs so they
+ * are not wrongly prefixed with `/docs`. Absolute, protocol-relative (`//`),
+ * anchor-only, and relative (`./`, `../`) links are left untouched.
+ */
+function resolveInBodyHref(target: string, page: DocsPage, baseUrl: string) {
+  const hashIndex = target.indexOf("#");
+  const hash = hashIndex === -1 ? "" : target.slice(hashIndex);
+  const path = hashIndex === -1 ? target : target.slice(0, hashIndex);
+
+  const resolved = getPageSource().getPageByHref(path, { dir: dirname(page.path) });
+  if (resolved) {
+    const resolvedHash = resolved.hash ? `#${resolved.hash}` : hash;
+    return `${baseUrl}${withDocsBasePath(resolved.page.url)}${resolvedHash}`;
+  }
+
+  // Not a docs page: treat as a site-root link (do not add the /docs base path).
+  return `${baseUrl}${target}`;
+}
+
+function absolutizeInBodyLinks(markdown: string, page: DocsPage, baseUrl: string) {
+  // Protect fenced code blocks, then inline code spans, so example code AND inline
+  // code containing markdown link syntax (e.g. `[label](/path)`) are left untouched
+  // by the rewrite below. Order matters: fences first, then inline spans.
+  const protectedFences = protectFencedCodeBlocks(markdown);
+  const protectedInline = protectInlineCode(protectedFences.markdown);
+
+  const rewritten = protectedInline.markdown.replace(
+    /\]\((\/[^)\s]*)\)/g,
+    (full, target: string) => {
+      if (target.startsWith("//")) return full;
+      return `](${resolveInBodyHref(target, page, baseUrl)})`;
+    },
+  );
+
+  return protectedFences.restore(protectedInline.restore(rewritten));
+}
+
 export async function getLLMText(page: DocsPage) {
-  const processed = normalizeProcessedMarkdown(await page.data.getText("processed"));
-  const breadcrumbLine = getBreadcrumbLine(page);
   const baseUrl = getBaseUrl();
+  const processed = absolutizeInBodyLinks(
+    normalizeProcessedMarkdown(await page.data.getText("processed")),
+    page,
+    baseUrl,
+  );
+  const breadcrumbLine = getBreadcrumbLine(page);
   const explicitRelatedPages = getExplicitRelatedPages(page, baseUrl);
   const relatedPages =
     explicitRelatedPages.length > 0
@@ -185,7 +236,17 @@ export async function getLLMText(page: DocsPage) {
   const context = breadcrumbLine ? `${breadcrumbLine}\n\n` : "";
   const related = formatRelatedPages(relatedPages);
 
+  const llmsTxtUrl = `${baseUrl}${withDocsBasePath("/llms.txt")}`;
+  const directive = `> For the complete Prisma documentation index, see [llms.txt](${llmsTxtUrl}). A markdown version of any docs page is available by appending \`.md\` to its URL.`;
+
+  const description =
+    typeof page.data.description === "string" && page.data.description.trim().length > 0
+      ? `\n\n${page.data.description.trim()}`
+      : "";
+
   return `# ${getPageTitleText(page.data.title, page.url)} (${withDocsBasePath(page.url)})
 
+${directive}${description}
+
 ${context}${processed}${related}`;
 }
diff --git a/apps/docs/src/lib/llm-markdown.ts b/apps/docs/src/lib/llm-markdown.ts
index 8dad6a84d1..d67d0a5f27 100644
--- a/apps/docs/src/lib/llm-markdown.ts
+++ b/apps/docs/src/lib/llm-markdown.ts
@@ -374,12 +374,50 @@ function replaceComponentBlocks(
   return result;
 }
 
-function protectFencedCodeBlocks(markdown: string) {
+// Base sentinel delimiter built from Unicode Private Use Area characters, which
+// cannot legitimately appear in MDX source. Real placeholder text a page might
+// discuss (e.g. `__LLM_INLINE_CODE_1__`) can never look like one of these
+// tokens, so protected content is never mistaken for a placeholder.
+const SENTINEL_DELIMITER = "\uE000\uE001";
+
+function escapeRegExp(value: string) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+/**
+ * Builds a collision-free placeholder scheme for one protector.
+ *
+ * The delimiter starts from PUA characters that cannot appear in MDX source and
+ * is lengthened deterministically until it is guaranteed absent from `input`, so
+ * a token can never collide with real content — including content that literally
+ * spells out one of these placeholders. `label` keeps the two protectors' tokens
+ * distinct so restoring one protector never touches the other's placeholders
+ * (cross-protector safety). `restore` performs a single left-to-right pass and so
+ * never rescans already-substituted content, which removes the corruption that a
+ * sequential per-token replace loop could introduce.
+ */
+function createProtector(input: string, label: string) {
+  let delimiter = SENTINEL_DELIMITER;
+  while (input.includes(delimiter)) delimiter += "\uE000";
+
+  const boundary = escapeRegExp(delimiter);
+  const pattern = new RegExp(`${boundary}${label}_(\\d+)${boundary}`, "g");
+
+  return {
+    token: (index: number) => `${delimiter}${label}_${index}${delimiter}`,
+    restore(value: string, blocks: readonly string[]) {
+      return value.replace(pattern, (match, index: string) => blocks[Number(index)] ?? match);
+    },
+  };
+}
+
+export function protectFencedCodeBlocks(markdown: string) {
   const blocks: string[] = [];
+  const protector = createProtector(markdown, "LLM_FENCED_CODE_BLOCK");
   const protectedMarkdown = markdown.replace(
     /^([ \t]*)([`~]{3,})[^\n]*\n[\s\S]*?^\1\2\s*$/gm,
     (match) => {
-      const token = `__LLM_FENCED_CODE_BLOCK_${blocks.length}__`;
+      const token = protector.token(blocks.length);
       blocks.push(match);
       return token;
     },
@@ -388,10 +426,31 @@ function protectFencedCodeBlocks(markdown: string) {
   return {
     markdown: protectedMarkdown,
     restore(value: string) {
-      return blocks.reduce(
-        (text, block, index) => text.replace(`__LLM_FENCED_CODE_BLOCK_${index}__`, block),
-        value,
-      );
+      return protector.restore(value, blocks);
+    },
+  };
+}
+
+/**
+ * Protects inline code spans (single or multiple backticks on a single line) so
+ * their literal contents — including markdown link syntax like `[label](/path)` —
+ * are left untouched by downstream text rewrites, then restored afterwards.
+ * Protect fenced code blocks FIRST, then inline spans, so the backticks that open
+ * and close a fence are never mistaken for an inline span.
+ */
+export function protectInlineCode(markdown: string) {
+  const spans: string[] = [];
+  const protector = createProtector(markdown, "LLM_INLINE_CODE");
+  const protectedMarkdown = markdown.replace(/(`+)[^\n]+?\1/g, (match) => {
+    const token = protector.token(spans.length);
+    spans.push(match);
+    return token;
+  });
+
+  return {
+    markdown: protectedMarkdown,
+    restore(value: string) {
+      return protector.restore(value, spans);
     },
   };
 }
diff --git a/apps/docs/src/lib/llms.ts b/apps/docs/src/lib/llms.ts
index 4b9973215c..7dffce66dd 100644
--- a/apps/docs/src/lib/llms.ts
+++ b/apps/docs/src/lib/llms.ts
@@ -21,11 +21,12 @@ type LLMsFullPage = {
   };
 };
 
-type LLMsSection = {
+export type LLMsSection = {
   slug: string;
   title: string;
   description: string;
   prefixes: string[];
+  excludePrefixes?: string[];
 };
 
 type LLMsExcludedProduct = {
@@ -61,6 +62,12 @@ export const commonQueries: LLMsLink[] = [
     href: "/prisma-orm/quickstart/prisma-postgres",
     description: "Set up Prisma ORM, Prisma Client, and Prisma Postgres in a new TypeScript app.",
   },
+  {
+    title: "Try Prisma Next (Early Access)",
+    href: "/next/getting-started",
+    description:
+      "Choose a Prisma Next quickstart for a new project or add Prisma Next to an existing app.",
+  },
   {
     title: "Connect to Prisma Postgres",
     href: "/postgres/database/connecting-to-your-database",
@@ -145,7 +152,8 @@ export const commonQueries: LLMsLink[] = [
   {
     title: "Use Prisma Postgres with Hono on Cloudflare Workers",
     href: "/guides/frameworks/hono",
-    description: "Set up Prisma ORM and Prisma Postgres in a Hono app deployed to Cloudflare Workers.",
+    description:
+      "Set up Prisma ORM and Prisma Postgres in a Hono app deployed to Cloudflare Workers.",
   },
 ];
 
@@ -153,8 +161,24 @@ export const llmsSections: LLMsSection[] = [
   {
     slug: "orm",
     title: "Prisma ORM",
-    description: "Prisma ORM setup, schema modeling, Prisma Client, migrations, and references.",
+    description:
+      "Current Prisma ORM docs: setup, schema modeling, Prisma Client, migrations, and references (excludes legacy v6 and Prisma Next).",
     prefixes: ["/orm", "/prisma-orm"],
+    excludePrefixes: ["/orm/v6", "/orm/next"],
+  },
+  {
+    slug: "orm-v6",
+    title: "Prisma ORM v6 (legacy)",
+    description:
+      "Legacy Prisma ORM v6 documentation, maintained for backwards compatibility only. Prefer the current Prisma ORM section for new work.",
+    prefixes: ["/orm/v6"],
+  },
+  {
+    slug: "next",
+    title: "Prisma Next (Early Access)",
+    description:
+      "Prisma Next, the next major version of Prisma ORM, available in Early Access. A ground-up TypeScript rewrite that keeps the schema-first workflow while making it extensible, composable, and AI-agent friendly. Covers setup, ORM, guides, and CLI docs for Prisma Next.",
+    prefixes: ["/next", "/orm/next", "/guides/next", "/cli/next"],
   },
   {
     slug: "postgres",
@@ -163,6 +187,49 @@ export const llmsSections: LLMsSection[] = [
       "Prisma Postgres setup, connection strings, local development, operations, and guides.",
     prefixes: ["/postgres", "/prisma-postgres"],
   },
+  {
+    slug: "guides",
+    title: "Guides",
+    description:
+      "End-to-end guides for using Prisma ORM and Prisma Postgres with popular frameworks and runtimes (Prisma Next guides live in the Prisma Next section).",
+    prefixes: ["/guides"],
+    excludePrefixes: ["/guides/next"],
+  },
+  {
+    slug: "ai",
+    title: "Prisma & AI",
+    description:
+      "Using Prisma with AI tools and agents: MCP server, editor integrations, prompts, and tutorials.",
+    prefixes: ["/ai"],
+  },
+  {
+    slug: "cli",
+    title: "Prisma CLI",
+    description:
+      "Prisma CLI command reference for init, generate, migrate, db, studio, and more (Prisma Next CLI docs live in the Prisma Next section).",
+    prefixes: ["/cli"],
+    excludePrefixes: ["/cli/next"],
+  },
+  {
+    slug: "platform",
+    title: "Prisma Platform",
+    description:
+      "Prisma Console and the Management API for managing projects, environments, and deployments.",
+    prefixes: ["/console", "/management-api"],
+  },
+  {
+    slug: "compute",
+    title: "Prisma Compute",
+    description:
+      "Prisma Compute (Public Beta): TypeScript app hosting that runs alongside Prisma Postgres, with database branches, isolated branch previews, and a CLI-first deploy workflow.",
+    prefixes: ["/compute"],
+  },
+  {
+    slug: "studio",
+    title: "Prisma Studio",
+    description: "Prisma Studio for browsing and editing data in your Prisma Postgres database.",
+    prefixes: ["/studio"],
+  },
   {
     slug: "query-insights",
     title: "Query Insights",
@@ -245,12 +312,34 @@ export function formatLLMsSectionLink(section: LLMsSection, baseUrl: string) {
   return `- [\`${section.title}\`](${href}): ${section.description}`;
 }
 
+function matchesPrefixList(url: string, prefixes: string[]) {
+  return prefixes.some((prefix) => url === prefix || url.startsWith(`${prefix}/`));
+}
+
+function pageBelongsToSection(url: string, section: LLMsSection) {
+  if (!matchesPrefixList(url, section.prefixes)) return false;
+  if (section.excludePrefixes && matchesPrefixList(url, section.excludePrefixes)) return false;
+  return true;
+}
+
 export function filterPagesForLLMsSection<T extends { url: string }>(
   pages: T[],
   section: LLMsSection,
 ) {
-  return pages.filter((page) =>
-    section.prefixes.some((prefix) => page.url === prefix || page.url.startsWith(`${prefix}/`)),
+  return pages.filter((page) => pageBelongsToSection(page.url, section));
+}
+
+/**
+ * Returns pages that are not covered by any of the provided sections. Used to
+ * guarantee full coverage in the root llms.txt: every non-excluded page must be
+ * reachable either directly in the root file or via a section file.
+ */
+export function getUnmatchedLLMsPages<T extends { url: string }>(
+  pages: T[],
+  sections: LLMsSection[],
+) {
+  return pages.filter(
+    (page) => !sections.some((section) => pageBelongsToSection(page.url, section)),
   );
 }
 
@@ -263,6 +352,100 @@ export function getLLMsSection(slug: string, pages?: LLMsPage[]) {
   return sections.find((section) => section.slug === slug);
 }
 
+function sortPagesByTitle<T extends LLMsPage>(pages: T[]) {
+  return [...pages].sort((a, b) =>
+    getPageTitleText(a.data.title, a.url).localeCompare(getPageTitleText(b.data.title, b.url)),
+  );
+}
+
+/**
+ * Builds the full body of the root `llms.txt` file. Shared by the route handler
+ * (`app/llms.txt/route.ts`) and the agent-readiness guard so the guard measures
+ * exactly what the route serves. Accepts the raw source pages; filtering and
+ * sorting happen here.
+ */
+export function buildLLMsIndexContent(pages: LLMsPage[], baseUrl: string): string {
+  const latestPages = sortPagesByTitle(filterPagesForLLMsIndex(pages));
+
+  const availableSections = filterAvailableLLMsSections(llmsSections, latestPages);
+
+  const commonQueriesList = filterAvailableLLMsLinks(commonQueries, latestPages)
+    .map((link) => formatLLMsLink(link, baseUrl))
+    .join("\n");
+  const subIndexList = availableSections
+    .map((section) => formatLLMsSectionLink(section, baseUrl))
+    .join("\n");
+  const otherPages = getUnmatchedLLMsPages(latestPages, availableSections);
+  const otherPagesList = otherPages.map((page) => formatLLMsPageLink(page, baseUrl)).join("\n");
+  const otherPagesSection = otherPagesList
+    ? `
+
+## Other pages
+
+${otherPagesList}`
+    : "";
+
+  return `# Prisma Documentation
+
+> **Prisma changes frequently — verify against the changelog and current docs before implementing.**
+> Do not rely on training data for Prisma features. APIs, configuration, and conventions can change between versions.
+>
+> First, fetch https://www.prisma.io/changelog.md to check for recent or relevant breaking changes,
+> then look up the relevant topic in the documentation below.
+
+> This index links to per-area indexes below. Each area index lists its pages with descriptions.
+> Append \`.md\` to any docs page URL to fetch its Markdown. Legacy Prisma ORM v6 pages are listed under
+> the "Prisma ORM v6 (legacy)" area and are maintained for backwards compatibility only.
+
+## Common Queries
+
+${commonQueriesList}
+
+## Product Area Indexes
+
+${subIndexList}${otherPagesSection}
+
+## Options
+
+- [Full documentation with content](${baseUrl}${withDocsBasePath("/llms-full.txt")})
+`;
+}
+
+/**
+ * Builds the full body of a per-area `llms/<slug>.txt` file. Shared by the route
+ * handler (`app/llms/[...slug]/route.ts`) and the agent-readiness guard. Accepts
+ * the index-filtered pages (`filterPagesForLLMsIndex(source.getPages())`);
+ * section filtering and sorting happen here.
+ */
+export function buildLLMsSectionContent(
+  section: LLMsSection,
+  pages: LLMsPage[],
+  baseUrl: string,
+): string {
+  const sectionPages = sortPagesByTitle(filterPagesForLLMsSection(pages, section));
+  const docsList =
+    sectionPages.map((page) => formatLLMsPageLink(page, baseUrl)).join("\n") ||
+    "_No pages currently match this section._";
+
+  return `# Prisma Documentation - ${section.title}
+
+> ${section.description}
+
+${docsList}
+`;
+}
+
+/**
+ * Pages included in `llms-full.txt`: the index-filtered set (excluded products
+ * removed) minus legacy Prisma ORM v6 pages. Shared by the route handler and the
+ * guard so the exclusion rules cannot drift between them.
+ */
+export function getLLMsFullPages<T extends LLMsPage>(pages: T[]): T[] {
+  return filterPagesForLLMsIndex(pages).filter(
+    (page) => page.url !== "/orm/v6" && !page.url.startsWith("/orm/v6/"),
+  );
+}
+
 export function createLLMsFullResponse<TPage extends LLMsFullPage>(
   description: string,
   pages: TPage[],
diff --git a/apps/docs/src/lib/mcp-discovery.ts b/apps/docs/src/lib/mcp-discovery.ts
new file mode 100644
index 0000000000..52cb2ad448
--- /dev/null
+++ b/apps/docs/src/lib/mcp-discovery.ts
@@ -0,0 +1,26 @@
+/**
+ * MCP discovery document served at /docs/.well-known/mcp and /docs/.well-known/mcp.json.
+ * The remote Prisma MCP server authenticates with Prisma Console via OAuth on first use.
+ * See content/docs/ai/tools/mcp-server.mdx.
+ */
+export const mcpDiscoveryDocument = {
+  version: "1.0.0",
+  transport: "http",
+  url: "https://mcp.prisma.io/mcp",
+  servers: [
+    {
+      name: "prisma",
+      url: "https://mcp.prisma.io/mcp",
+      transport: "http",
+      authentication: "oauth",
+    },
+  ],
+} as const;
+
+export function mcpDiscoveryResponse() {
+  return new Response(JSON.stringify(mcpDiscoveryDocument, null, 2), {
+    headers: {
+      "Content-Type": "application/json; charset=utf-8",
+    },
+  });
+}
diff --git a/apps/site/src/app/.well-known/agent-skills/index.json/route.ts b/apps/site/src/app/.well-known/agent-skills/index.json/route.ts
new file mode 100644
index 0000000000..2eba9691b4
--- /dev/null
+++ b/apps/site/src/app/.well-known/agent-skills/index.json/route.ts
@@ -0,0 +1,11 @@
+import { buildAgentSkillsIndex } from "@/lib/agent-skills";
+
+export const revalidate = false;
+
+export async function GET() {
+  return new Response(JSON.stringify(buildAgentSkillsIndex(), null, 2), {
+    headers: {
+      "Content-Type": "application/json; charset=utf-8",
+    },
+  });
+}
diff --git a/apps/site/src/app/.well-known/agent-skills/prisma/SKILL.md/route.ts b/apps/site/src/app/.well-known/agent-skills/prisma/SKILL.md/route.ts
new file mode 100644
index 0000000000..2f7ad2b4f1
--- /dev/null
+++ b/apps/site/src/app/.well-known/agent-skills/prisma/SKILL.md/route.ts
@@ -0,0 +1,11 @@
+import { buildSkillMarkdown } from "@/lib/agent-skills";
+
+export const revalidate = false;
+
+export async function GET() {
+  return new Response(buildSkillMarkdown(), {
+    headers: {
+      "Content-Type": "text/markdown; charset=utf-8",
+    },
+  });
+}
diff --git a/apps/site/src/app/.well-known/mcp.json/route.ts b/apps/site/src/app/.well-known/mcp.json/route.ts
new file mode 100644
index 0000000000..2162e60388
--- /dev/null
+++ b/apps/site/src/app/.well-known/mcp.json/route.ts
@@ -0,0 +1,11 @@
+import { buildMcpDiscovery } from "@/lib/agent-skills";
+
+export const revalidate = false;
+
+export async function GET() {
+  return new Response(JSON.stringify(buildMcpDiscovery(), null, 2), {
+    headers: {
+      "Content-Type": "application/json; charset=utf-8",
+    },
+  });
+}
diff --git a/apps/site/src/app/.well-known/mcp/route.ts b/apps/site/src/app/.well-known/mcp/route.ts
new file mode 100644
index 0000000000..2162e60388
--- /dev/null
+++ b/apps/site/src/app/.well-known/mcp/route.ts
@@ -0,0 +1,11 @@
+import { buildMcpDiscovery } from "@/lib/agent-skills";
+
+export const revalidate = false;
+
+export async function GET() {
+  return new Response(JSON.stringify(buildMcpDiscovery(), null, 2), {
+    headers: {
+      "Content-Type": "application/json; charset=utf-8",
+    },
+  });
+}
diff --git a/apps/site/src/app/.well-known/mcp/server-card.json/route.ts b/apps/site/src/app/.well-known/mcp/server-card.json/route.ts
new file mode 100644
index 0000000000..946d62e2a0
--- /dev/null
+++ b/apps/site/src/app/.well-known/mcp/server-card.json/route.ts
@@ -0,0 +1,11 @@
+import { buildMcpServerCard } from "@/lib/agent-skills";
+
+export const revalidate = false;
+
+export async function GET() {
+  return new Response(JSON.stringify(buildMcpServerCard(), null, 2), {
+    headers: {
+      "Content-Type": "application/json; charset=utf-8",
+    },
+  });
+}
diff --git a/apps/site/src/app/.well-known/mcp/server-cards.json/route.ts b/apps/site/src/app/.well-known/mcp/server-cards.json/route.ts
new file mode 100644
index 0000000000..fd3e35fb1f
--- /dev/null
+++ b/apps/site/src/app/.well-known/mcp/server-cards.json/route.ts
@@ -0,0 +1,11 @@
+import { buildMcpServerCards } from "@/lib/agent-skills";
+
+export const revalidate = false;
+
+export async function GET() {
+  return new Response(JSON.stringify(buildMcpServerCards(), null, 2), {
+    headers: {
+      "Content-Type": "application/json; charset=utf-8",
+    },
+  });
+}
diff --git a/apps/site/src/app/skill.md/route.ts b/apps/site/src/app/skill.md/route.ts
new file mode 100644
index 0000000000..2f7ad2b4f1
--- /dev/null
+++ b/apps/site/src/app/skill.md/route.ts
@@ -0,0 +1,11 @@
+import { buildSkillMarkdown } from "@/lib/agent-skills";
+
+export const revalidate = false;
+
+export async function GET() {
+  return new Response(buildSkillMarkdown(), {
+    headers: {
+      "Content-Type": "text/markdown; charset=utf-8",
+    },
+  });
+}
diff --git a/apps/site/src/lib/agent-skills.ts b/apps/site/src/lib/agent-skills.ts
new file mode 100644
index 0000000000..7856afd4be
--- /dev/null
+++ b/apps/site/src/lib/agent-skills.ts
@@ -0,0 +1,296 @@
+import { getBaseUrl } from "@/lib/url";
+
+/**
+ * Shared content for agent-facing discovery endpoints:
+ * - Agent skill discovery (skill.md + /.well-known/agent-skills/*)
+ * - MCP server discovery (/.well-known/mcp*)
+ *
+ * All content is grounded in the official Prisma documentation. Do not invent
+ * commands, flags, tools, or APIs here — keep this in sync with the docs.
+ */
+
+export const SKILL_NAME = "prisma";
+export const MCP_SERVER_URL = "https://mcp.prisma.io/mcp";
+
+const SKILL_DESCRIPTION =
+  "Build type-safe TypeScript and Node.js apps with Prisma ORM and Prisma Postgres. Covers the core Prisma CLI workflow (init, migrate, generate, studio), connecting to a Prisma Postgres database, and the remote Prisma MCP server for managing databases from AI tools.";
+
+/**
+ * Tools exposed by the remote Prisma MCP server, as documented in
+ * apps/docs/content/docs/ai/tools/mcp-server.mdx. Names and one-line
+ * descriptions are copied from the docs; input schemas are not documented.
+ */
+export const MCP_TOOLS: { name: string; description: string }[] = [
+  {
+    name: "CreateBackupTool",
+    description: "Create a new managed Prisma Postgres Backup.",
+  },
+  {
+    name: "CreateConnectionStringTool",
+    description: "Create a new Connection String for a Prisma Postgres database with the given id.",
+  },
+  {
+    name: "CreateRecoveryTool",
+    description: "Restore a Prisma Postgres Database to a new database with the given Backup id.",
+  },
+  {
+    name: "DeleteConnectionStringTool",
+    description: "Delete a Connection String with the given connection string id.",
+  },
+  {
+    name: "DeleteDatabaseTool",
+    description: "Delete a Prisma Postgres database with the given id.",
+  },
+  {
+    name: "ListBackupsTool",
+    description:
+      "Fetch a list of available Prisma Postgres Backups for the given database id and environment id.",
+  },
+  {
+    name: "ListConnectionStringsTool",
+    description:
+      "Fetch a list of available Prisma Postgres Database Connection Strings for the given database id and environment id.",
+  },
+  {
+    name: "ListDatabasesTool",
+    description: "Fetch a list of available Prisma Postgres Databases for user's workspace.",
+  },
+  {
+    name: "ExecuteSqlQueryTool",
+    description: "Execute a SQL query on a Prisma Postgres database with the given id.",
+  },
+  {
+    name: "IntrospectSchemaTool",
+    description: "Introspect the schema of a Prisma Postgres database with the given id.",
+  },
+  {
+    name: "search_prisma_documentation",
+    description:
+      "Answer a natural-language question about Prisma using the official Prisma documentation, returning a cited answer with links back to the docs.",
+  },
+];
+
+/**
+ * The Prisma agent skill in agentskills.io format: YAML frontmatter followed by
+ * a markdown body. Served at /skill.md and /.well-known/agent-skills/prisma/SKILL.md.
+ */
+export function buildSkillMarkdown(baseUrl = getBaseUrl()): string {
+  const docsUrl = `${baseUrl}/docs`;
+
+  return `---
+name: ${SKILL_NAME}
+description: ${SKILL_DESCRIPTION}
+license: Apache-2.0
+compatibility: ">=0.1.0"
+metadata:
+  homepage: ${baseUrl}
+  documentation: ${docsUrl}
+  vendor: Prisma
+  version: "1.0.0"
+allowed-tools:
+  - Bash
+  - Read
+  - Edit
+  - Write
+---
+
+# Prisma
+
+Prisma is agent infrastructure for TypeScript and Node.js. This skill covers two
+products:
+
+- **Prisma ORM** — a type-safe ORM for Node.js and TypeScript with schema
+  modeling, automated migrations, and an intuitive query API. It supports
+  PostgreSQL, MySQL, SQL Server, SQLite, MongoDB, and CockroachDB.
+- **Prisma Postgres** — a fully managed PostgreSQL database that scales to zero
+  and integrates with Prisma ORM and Prisma Studio.
+
+> Prisma changes frequently. Before implementing Prisma features, check the
+> changelog at ${baseUrl}/changelog.md and the current documentation. Do not rely
+> solely on training data for Prisma APIs, configuration, or conventions — these
+> can change between versions.
+
+## Core workflow (Prisma CLI)
+
+Run the Prisma CLI with \`npx prisma\`. The typical workflow for a new project:
+
+1. **Set up a TypeScript project with ESM.** Initialize the project, install
+   dependencies, and enable ESM before scaffolding Prisma:
+
+   \`\`\`bash
+   npm init -y
+   npm install typescript tsx @types/node --save-dev
+   npx tsc --init
+   npm install prisma @types/pg --save-dev
+   npm install @prisma/client @prisma/adapter-pg pg dotenv
+   \`\`\`
+
+   Set \`"module": "ESNext"\` (along with \`"moduleResolution": "bundler"\`,
+   \`"target": "ES2023"\`, \`"strict": true\`, \`"esModuleInterop": true\`, and
+   \`"ignoreDeprecations": "6.0"\`) in \`tsconfig.json\`, and add
+   \`"type": "module"\` to \`package.json\`.
+
+2. **Initialize Prisma ORM.** Creates the \`prisma/\` directory with a
+   \`schema.prisma\` file, a \`.env\` file, and a \`prisma.config.ts\` file:
+
+   \`\`\`bash
+   npx prisma init --output ../generated/prisma
+   \`\`\`
+
+3. **Create a Prisma Postgres database.** Ask the user for approval before
+   provisioning a hosted Prisma Postgres database — \`npx create-db\` creates a
+   cloud resource. After approval, run it and copy the \`postgres://...\`
+   connection string into \`DATABASE_URL\` in your \`.env\` file:
+
+   \`\`\`bash
+   npx create-db
+   \`\`\`
+
+4. **Create and apply a migration** after defining models in
+   \`prisma/schema.prisma\`. This creates the database tables based on your schema:
+
+   \`\`\`bash
+   npx prisma migrate dev --name init
+   \`\`\`
+
+5. **Generate Prisma Client** for type-safe database access:
+
+   \`\`\`bash
+   npx prisma generate
+   \`\`\`
+
+6. **Explore your data** in Prisma Studio, a visual database editor:
+
+   \`\`\`bash
+   npx prisma studio
+   \`\`\`
+
+### Example schema
+
+\`\`\`prisma
+generator client {
+  provider = "prisma-client"
+  output   = "../generated/prisma"
+}
+
+datasource db {
+  provider = "postgresql"
+}
+
+model User {
+  id    Int     @id @default(autoincrement())
+  email String  @unique
+  name  String?
+  posts Post[]
+}
+
+model Post {
+  id        Int     @id @default(autoincrement())
+  title     String
+  content   String?
+  published Boolean @default(false)
+  author    User    @relation(fields: [authorId], references: [id])
+  authorId  Int
+}
+\`\`\`
+
+## Remote MCP server
+
+Prisma runs a remote Model-Context-Protocol (MCP) server that lets AI tools
+manage Prisma Postgres databases over HTTP transport. It authenticates with
+Prisma Console on first use so your AI tool can access the workspace you choose.
+
+Endpoint: \`${MCP_SERVER_URL}\`
+
+Standard MCP configuration:
+
+\`\`\`json
+{
+  "mcpServers": {
+    "Prisma": {
+      "url": "${MCP_SERVER_URL}"
+    }
+  }
+}
+\`\`\`
+
+The server exposes tools for creating and listing databases, connection strings,
+and backups; restoring backups; running SQL queries; introspecting schemas; and
+\`search_prisma_documentation\`, which answers Prisma questions grounded in the
+official docs with citations. Once connected, you can prompt your agent to
+"List the Prisma tools" for the latest supported tools.
+
+## Where to read the docs
+
+- Docs index (machine-readable): ${baseUrl}/docs/llms.txt
+- Full docs corpus: ${baseUrl}/docs/llms-full.txt
+- Any docs page as markdown: append \`.md\` to the URL (e.g. ${baseUrl}/docs/getting-started.md)
+- Changelog (machine-readable): ${baseUrl}/changelog.md
+`;
+}
+
+/**
+ * Index of available agent skills, served at
+ * /.well-known/agent-skills/index.json.
+ */
+export function buildAgentSkillsIndex(baseUrl = getBaseUrl()) {
+  return {
+    version: "1.0.0",
+    skills: [
+      {
+        name: SKILL_NAME,
+        description: SKILL_DESCRIPTION,
+        url: `${baseUrl}/.well-known/agent-skills/${SKILL_NAME}/SKILL.md`,
+      },
+    ],
+  };
+}
+
+/**
+ * MCP discovery document, served at /.well-known/mcp and /.well-known/mcp.json.
+ */
+export function buildMcpDiscovery() {
+  return {
+    version: "1.0.0",
+    transport: "http",
+    url: MCP_SERVER_URL,
+    servers: [
+      {
+        name: "prisma",
+        url: MCP_SERVER_URL,
+        transport: "http",
+        authentication: "oauth",
+      },
+    ],
+  };
+}
+
+/**
+ * MCP server card, served at /.well-known/mcp/server-card.json.
+ */
+export function buildMcpServerCard() {
+  return {
+    name: "Prisma MCP",
+    description:
+      "Manage Prisma Postgres databases using natural language. Create and list databases, connection strings, and backups; run SQL queries; introspect schemas; and search the Prisma documentation.",
+    version: "1.0.0",
+    serverInfo: {
+      name: "prisma",
+      version: "1.0.0",
+    },
+    url: MCP_SERVER_URL,
+    transport: "http",
+    capabilities: {
+      tools: true,
+    },
+    authentication: "oauth",
+    tools: MCP_TOOLS,
+  };
+}
+
+/**
+ * MCP server cards collection, served at /.well-known/mcp/server-cards.json.
+ */
+export function buildMcpServerCards() {
+  return [buildMcpServerCard()];
+}
diff --git a/turbo.json b/turbo.json
index dd84a53b4d..7e6c07d2f8 100644
--- a/turbo.json
+++ b/turbo.json
@@ -31,6 +31,7 @@
       "dependsOn": ["^types:check"]
     },
     "lint:links": {},
+    "lint:agent-ready": {},
     "lint:external-links": {},
     "lint:code": {},
     "lint:spellcheck": {}