ChatGPT answers, unedited

Yes. There are now tools specifically aimed at this problem, but they fall into two slightly different categories:

Best fit for what you described

GitBook is probably the closest match if you want to know which AI agents are accessing your docs, what they're asking for, and where the documentation has gaps. Its 2026 AI-agent analytics can show the AI tools hitting your docs and the queries they send, which lets you identify questions your docs aren't answering well. www.gitbook.com

For example, you could discover:

AI agents frequently ask "How do I rotate an API key?"
→ They hit three pages
→ No page directly answers the question
→ Recommendation: create a dedicated API-key rotation page and cross-link it from authentication docs.

Other tools worth evaluating

Mintlify is particularly interesting if you're already using it: its assistant analytics let you export queries, responses, and sources, then analyze things like unanswered questions and missing coverage. mintlify.com

If your real question is "Which of our individual documentation pages are ChatGPT/Claude/Gemini actually using when answering questions about our product?", that's a narrower problem. Tools like Citations.io measure AI visibility and the sources cited by ChatGPT, Gemini, Perplexity, and Claude, while GitBook/Mintlify are more focused on agents interacting with your documentation directly. citations.io

What I'd recommend for a technical-docs team

I'd separate the measurement into three metrics:

1. AI discovery — Which AI assistants/agents visit or retrieve your docs?
2. AI usage — Which pages are actually retrieved/cited in answers?
3. AI gaps — What questions are users/agents asking that your docs don't answer adequately?

Then build a feedback loop:

AI queries → pages retrieved → answer quality → missing/weak content → suggested doc change → measure again

If you tell me where your docs currently live (GitHub/Markdown, GitBook, Mintlify, ReadMe, custom site, etc.), I can recommend the best 2–3 tools for your setup, including which ones can actually identify specific docs being used by ChatGPT/Claude/etc. rather than merely measuring AI traffic.

Yes. What you’re describing is a newer category: AI documentation / AI discoverability analytics. The key distinction is whether you want to measure AI agents actually reading your docs versus measuring whether AI assistants mention/cite your company.

Best fits

• mintlify.com — probably the closest match if you want documentation-level analytics. Its agent analytics can show which AI agents access your docs, which pages they read, and searches/queries they make. It also supports llms.txt, Markdown delivery, MCP, and other agent-oriented features. Mintlify Mintlify
• gitbook.com — particularly interesting if you want to identify what AI assistants are trying to find. Its 2026 AI analytics reportedly expose AI tools and the queries they send, which can reveal documentation gaps. GitBook GitBook
• readme.com — has an explicit AI Discoverability score that crawls your published docs and evaluates them against an agent-friendly documentation specification, then recommends configuration/content improvements. ReadMe
• citations.io — different but useful: it repeatedly asks questions across ChatGPT, Gemini, Perplexity, and Claude and measures whether your company is mentioned, where you appear, and which sources those assistants cite. This is more AI visibility/share-of-voice than documentation analytics. Citations.io

What I'd recommend for a technical-docs team

If your question is:

"Which of our docs are AI assistants actually using, what are they looking for, and what should our writers change?"

I'd start by evaluating Mintlify and GitBook.

The ideal system should give you a funnel something like:

AI assistant → query → documentation page(s) retrieved → answer/citation → gap/unanswered question → recommended doc change

That's more valuable than simply knowing that "ChatGPT visited our site."

There's also an important distinction between AI traffic and AI referrals. An agent can fetch your documentation behind the scenes and answer a developer's question without the developer ever clicking through to your site, so Google Analytics alone won't capture much of this activity. Mintlify

If you're not looking to change your documentation platform, I can also find tools that sit on top of your existing docs (GitHub/Docusaurus/MkDocs/ReadMe/etc.) and specifically analyze AI consumption + identify content gaps + suggest concrete edits. That may be a better fit for a technical-writing organization.

Yes. What you’re describing is broader than ordinary SEO: AI/LLM documentation visibility + retrieval analysis—figuring out which pages AI assistants actually retrieve/cite, where they fail to find the answer, and what content changes would improve that.

A few tools are worth looking at:

If your goal is specifically “which of our docs are AI assistants using?”

I'd prioritize kapa.ai or Biel.ai, but I'd distinguish two jobs:

1. Measure AI visibility

• Ask hundreds of realistic developer questions.
• See which documentation URLs are retrieved/cited.
• Measure citation rate and answer accuracy.
• Identify questions where your docs should have been cited but weren't.
• Compare your documentation against competitors.

2. Improve the documentation

• Detect missing answers.
• Find pages that are difficult for retrieval systems to understand.
• Identify fragmented answers spread across multiple pages.
• Recommend better headings, terminology, examples, and page structure.
• Turn unanswered questions into new documentation topics.

Biel specifically describes its approach as testing how AI retrieves and quotes documentation, while kapa.ai emphasizes coverage-gap detection, retrieval accuracy, citations, and evaluation suites for technical content. biel.ai

One important caveat: don't equate llms.txt with AI visibility measurement. It's useful as a machine-readable map of your docs, and some documentation platforms now support it, but evidence that major AI search engines use it as a ranking/citation signal is still weak. documentation.ai

What I'd build for a documentation team

If you're evaluating this as an internal capability, I'd want a dashboard roughly like:

AI Documentation Score

• 1,000 representative developer questions
• % answered correctly
• % citing your docs
• URLs cited most frequently
• URLs never retrieved
• competitor citation share
• hallucination/error rate
• questions with no adequate documentation
• recommended documentation changes

Then drill down to:

“How do I configure OAuth?”
AI answer: partially correct
Expected source: /authentication/oauth
Actually cited: /getting-started
Problem: OAuth configuration details are buried 4 sections deep.
Recommendation: Add a self-contained OAuth configuration section and link it from the authentication overview.

That is much more valuable than simply checking whether you have an llms.txt.

If you tell me what your docs stack is (e.g. ReadMe, Docusaurus, Mintlify, GitBook, custom site) and whether you care about ChatGPT/Claude/Gemini/Cursor/Copilot, I can narrow this down to the 2–3 best tools and explain exactly what each can measure.

Yes. There are a few emerging tools specifically aimed at this, but they fall into two different categories:

1. Best fit: measure how AI systems use your docs

Kapa.ai is probably the closest match to what you're describing. It ingests technical documentation and analyzes the questions people/agents ask against it. Its analytics can show which questions are being asked, where answers are missing, and which sources are driving successful answers, which can directly inform documentation improvements. www.kapa.ai

It is particularly oriented toward technical content—API docs, developer docs, GitHub, PDFs, support tickets, etc.—rather than generic SEO.

2. AI-search visibility / citation tracking

If by "used by AI assistants" you mean:

When someone asks ChatGPT/Claude/Gemini about our product, does the AI cite or recommend our documentation?

then you want an AI visibility / GEO/AEO platform.

Profound is one example. It tracks AI visibility, citations, and AI bot visits, including visibility across systems such as ChatGPT, Perplexity, and Gemini. Anthropic even exposes a Profound connector for querying this data from Claude. claude.com

Pendium is another example focused on monitoring how AI assistants perceive and recommend a brand, with recommendations for improving AI visibility. pendium.ai

3. If you own the docs platform

If you're using a documentation platform with its own AI assistant, Documentation.AI has particularly relevant analytics. It tracks AI-assistant questions, sessions, low-confidence answers, satisfaction, and the page context where questions originated. documentation.ai

What I'd recommend for a technical-docs team

I'd distinguish the problem into these metrics:

The interesting opportunity is combining all of these. For a technical documentation organization, I wouldn't just look for a conventional "AI SEO" tool. I'd look for something that can take your corpus and produce a report like:

AI usage: 37% of tested developer questions cite our docs.
Most-used pages: Authentication, API reference, Webhooks.
Underused pages: Migration guide, troubleshooting.
Content gaps: 14 high-frequency questions have no authoritative answer.
Retrieval problems: Authentication has 3 competing pages with overlapping terminology.
Recommended fixes: consolidate pages, add explicit examples, clarify terminology, add missing API parameters.
AI visibility: competitors are cited for 11 questions where we aren't.

That would be much more useful to a documentation team than simply an "AI SEO score."

If you tell me what documentation stack you use (GitBook, ReadMe, Mintlify, Docusaurus, Confluence, custom, etc.) and whether you mean ChatGPT/Claude/Gemini usage or an AI assistant embedded in your docs, I can narrow this down to the 3–5 tools that actually fit your workflow and compare them on capabilities/pricing.

Yes. What you’re describing is essentially AI documentation analytics / GEO (Generative Engine Optimization): a tool that can tell you which documentation AI systems retrieve/cite, what questions they’re trying to answer, where they fail, and what content should be improved.

Tools I’d look at

1. Mintlify — probably the closest fit

Mintlify has moved beyond documentation hosting into AI-specific documentation analytics. Its analytics can expose AI traffic, assistant queries, responses, and the sources used, while its GEO tooling evaluates whether docs are structured in ways AI systems can understand and cite. www.mintlify.com

It can help answer things like:

• Which docs are being retrieved by AI?
• What questions are users asking?
• Which questions aren't adequately answered?
• Which pages are high-traffic but need improvement?
• Are answers citing the right source?
• Are there content gaps?
• How should pages be structured to be more AI-citable?

It also supports AI-readable Markdown, llms.txt, MCP, and other agent-oriented interfaces. www.mintlify.com

2. Documentation.AI

Documentation.AI has particularly explicit Ask AI Analytics. It tracks questions, sessions, low-confidence answers, satisfaction, page context, and lets you export the data for deeper analysis. documentation.ai

This looks interesting if you already have a documentation stack and primarily want an AI layer + analytics, rather than replacing your docs platform.

One important distinction

There are actually two different problems you may want to measure:

If your goal is specifically “we have 5,000 technical docs; analyze them and tell us which ones AI assistants actually use and what we should change”, I would not limit the search to documentation platforms. You want an AI-visibility/GEO product that can crawl your existing corpus and combine it with AI query/citation data.

If you tell me where your docs currently live (GitHub/Markdown, GitBook, Confluence, ReadMe, custom site, etc.), I can find the 3–5 tools that best match that setup, including ones that can measure actual ChatGPT/Claude/Perplexity visibility rather than just their own embedded assistant.

Yes. The closest fit I found is Mintlify, particularly if you publish your technical docs through it.

What I’d look at

1. Mintlify — strongest match

• Identifies AI-agent traffic hitting your documentation and shows which agents visit and which pages they access. www.mintlify.comwww.mintlify.comdocumentation.ai
• Tracks searches and docs-assistant conversations, giving you actual questions users/agents are asking.
• Its agent suggestions analyze those conversations and surface documentation gaps—e.g. places where you should clarify a concept, add an example, or restructure content. www.mintlify.com
• Its analytics can now be accessed programmatically via mint analytics, including assistant conversations, searches, feedback, and page-level data, which is useful if you want to build your own analysis workflow. www.mintlify.comwww.mintlify.com
• It also supports AI-oriented mechanisms such as llms.txt, skill.md, content negotiation, and MCP. www.mintlify.comwww.mintlify.comdocumentation.ai

This is particularly interesting because Mintlify reports that on its highest-traffic docs sites, agent traffic can represent 28–82% of traffic depending on industry. www.mintlify.com

2. Documentation.AI — worth evaluating
Documentation.AI has an AI Assistant with analytics showing total questions, sessions, recent questions, page context, and exports. It explicitly positions repeated questions and weak answer coverage as signals for improving documentation. documentation.ai

3. Atlassian Rovo — different use case
If your docs live in Confluence, Atlassian Rovo is useful for seeing how an enterprise AI searches and reasons over your internal knowledge. It can search across Confluence and other connected sources, but it's less specifically focused on "which of our docs are AI assistants using, and how should we improve those docs?" support.atlassian.com

If you're building this capability yourselves

I'd define the product around four signals:

Then generate a per-page AI Readiness Score, with recommendations such as:

Authentication.md — High AI usage, poor coverage
1,240 AI fetches/month · cited in 18% of relevant answers
Common unanswered question: “How do I refresh an expired token?”
Recommendation: Add a token-refresh example and explicitly document expiration behavior.

If your goal is specifically to understand how ChatGPT/Claude/Gemini/Copilot/etc. are consuming your public technical docs, I'd start with Mintlify. It is currently much closer to that exact problem than generic documentation analytics tools. www.mintlify.comwww.mintlify.com

If you tell me where your docs are hosted (GitHub, ReadMe, Docusaurus, Confluence, custom site, etc.), I can identify the best 3–5 tools for your setup and compare what each can actually measure.

Yes. The category you want is AI documentation visibility / AI-citation analytics: tools that test what happens when real developer questions are asked to ChatGPT, Claude, Gemini, Perplexity, coding agents, etc., then show which docs get retrieved/cited and where your content loses to competitors.

Tools I'd evaluate

1. Kapa.ai — probably the closest fit if you're producing technical/developer documentation. It focuses on technical content, can ingest docs, code, PDFs and support material, and offers coverage-gap analytics showing where your documentation doesn't adequately answer technical questions. www.kapa.ai

2. Citare — more specifically focused on measuring AI search visibility. It can track queries across AI surfaces, parse citations, measure "surface rate," and benchmark against competitors. That's particularly relevant if your question is "Which of our docs are actually being cited by AI?" rather than "Can we put an AI chatbot on our docs?" www.citare.ai

3. ReadMe — worth considering if you also control the documentation platform. Its AI Discoverability feature grades docs against an agent-friendly specification and checks things such as llms.txt, crawlability and machine-readable content. docs.readme.com

4. GitBook — increasingly AI-native. It provides AI optimization, Markdown delivery, llms.txt, MCP, and an AI assistant; its Agent can also suggest documentation updates. gitbook.com

5. Mintlify — another AI-native docs platform with AI-readability features and AI traffic analytics. It's more compelling if you're considering changing your documentation stack rather than simply analyzing an existing one. www.mintlify.com

For your specific use case

I'd separate the problem into three measurements:

The interesting part is the third and fourth rows. Traditional web analytics won't tell you that. AI agents can consume a page in one or two requests, so metrics like pageviews, time-on-page and navigation paths can be misleading. arxiv.org

For example, you ideally want a system to run questions such as:

"How do I authenticate with Product X's API using OAuth?"

and report something like:

• Your docs cited: oauth.md — 0%
• Competitor cited: competitor.com/oauth — 72%
• Your best relevant page: authentication.md
• Problem: doesn't explicitly answer OAuth setup
• Recommendation: add a task-oriented OAuth example + prerequisites + complete code sample
• After revision: re-run the query and measure citation rate

That is much more useful to a technical-writing team than an ordinary "AI chatbot for docs."

If you tell me what your current docs stack is (e.g. Markdown/GitHub, GitBook, ReadMe, Docusaurus, custom site, etc.), I can narrow this down to the 2–3 tools I'd actually pilot, including what each can measure and where the gaps are.

Yes. If by “analyze which docs are used by AI assistants” you mean see which AI agents are accessing your docs, which pages they retrieve, what they search for, where they fail, and what content should be improved, there are now tools specifically aimed at this.

My top picks

1. Mintlify — probably the closest match

Mintlify has unusually strong AI-agent analytics. Its analytics can distinguish AI-agent traffic from human traffic, show which AI agents are visiting, which pages they access, and what queries they make through MCP. It also exposes assistant conversations, cited sources, and answered vs. unanswered queries. www.mintlify.com

That gives you a workflow like:

AI query → retrieved docs → answer → success/failure → documentation gap → suggested fix

It can also help make docs more AI-consumable through Markdown, llms.txt, skill.md, MCP, structured headings, metadata, etc. www.mintlify.com

2. GitBook

GitBook is another strong option if you're already considering a docs platform. Its AI features provide AI search/Assistant, and its current platform direction includes AI-agent analytics as well as llms.txt and MCP support. gitbook.comwww.gitbook.com

3. Kapa

Kapa.ai is worth looking at if you don't want to migrate your documentation platform. It's more of an AI knowledge/retrieval layer for technical documentation and has question/gap analytics. The 2026 comparison from GitBook lists Kapa as supporting multi-surface AI answers, MCP, and question/gap analytics. gitbook.comwww.gitbook.com

What I'd look for in your case

If you're producing technical docs and want to optimize specifically for ChatGPT, Claude, Cursor, coding agents, etc., don't settle for ordinary page-view analytics. You want these metrics:

Mintlify is the one I'd investigate first because it combines the analytics side with the actual documentation infrastructure. Its current analytics explicitly expose AI-agent traffic and MCP searches, while its assistant analytics expose queries, responses, sources, and resolution status. www.mintlify.com

One important distinction: “AI traffic analytics” and “AI documentation optimization” aren't quite the same thing. The really interesting product for your team would analyze your corpus and tell you something like:

“Authentication > OAuth is retrieved for 31% of authentication-related AI questions, but 18% of those answers are unsuccessful. The page lacks an explicit explanation of refresh-token rotation. Add a dedicated section and link it from these three pages.”

If that's what you're looking for, I can research the current market specifically for tools that ingest an existing technical-doc corpus and automatically identify AI retrieval gaps + recommend concrete documentation changes, rather than just docs platforms with AI chat.

Yes. What you’re describing is a relatively new category: AI documentation visibility / AI discoverability—tools that determine whether assistants such as ChatGPT, Claude, Gemini, Cursor, and Copilot can find, retrieve, understand, and cite your docs.

Tools I’d look at

But there's an important distinction

If your goal is specifically:

“Which of our docs are AI assistants actually using, and what should we change so they use them more?”

I'd prioritize Cite AI or Citare/Pendium over a conventional documentation platform.

You want two kinds of data:

1. Actual AI usage

• Which of your URLs get cited by ChatGPT/Claude/Gemini/Perplexity/etc.
• Which questions cause your docs to appear
• Which competitors get cited instead
• Citation frequency / visibility over time
• Which sections/pages are never retrieved

2. Documentation quality for AI retrieval

• Can crawlers discover the docs?
• Is there clean Markdown?
• Are pages too long or ambiguous?
• Are titles and headings descriptive?
• Are canonical URLs/version information clear?
• Are code examples extractable?
• Are important concepts buried behind navigation?
• Are there conflicting/outdated pages?
• Is llms.txt/other agent-access infrastructure configured?

ReadMe, for example, actually crawls published pages and scores them against an agent-friendly documentation specification. docs.readme.com

One caveat: don't over-index on llms.txt

It's useful infrastructure, but it isn't the same thing as measuring AI usage. A 2026 analysis of 137K sites found that 97% of llms.txt files received no traffic during the study period. ahrefs.com

So I'd build your evaluation around “Are AI systems finding and citing our docs?”, with llms.txt, Markdown endpoints, MCP, etc. treated as mechanisms that may improve that outcome—not the outcome itself.

If you're evaluating this for a technical-writing/docs team, I can also give you a shortlist of the 5–7 strongest tools specifically for analyzing an existing documentation corpus, including what each one measures, pricing, integrations, and which I'd pick for your use case.

Yes. What you’re looking for is essentially AI visibility / GEO (Generative Engine Optimization) for technical documentation: a tool that can determine whether AI assistants can find, understand, cite, and correctly use your docs—and then tell your docs team what to change.

Tools I’d shortlist

For your specific use case

I'd distinguish two different questions:

1. "Are AI assistants actually using our docs?"
You want analytics showing things like:

• Which docs/pages are being retrieved or cited
• Which AI questions lead to your documentation
• Which pages are never surfaced
• Which docs are frequently cited vs. ignored
• Whether AI gives the correct answer from your docs
• Which competitor docs get cited instead
• Where AI can't find an answer

2. "How should we improve the docs so AI uses them better?"
You want recommendations around:

• document structure and headings
• terminology and entity clarity
• API/reference organization
• code examples
• chunkability/retrieval
• canonical answers to common questions
• outdated/contradictory information
• missing topics
• llms.txt / machine-readable content
• MCP and other agent-access mechanisms

For technical documentation specifically, I'd start by evaluating Hikoo + Kapa. Hikoo is closer to "how visible/understandable are our docs to external AI?", while Kapa is closer to "what questions are AI/users asking, and where are our documentation gaps?" www.kapa.aiwww.tryhikoo.com

There's also an emerging distinction worth knowing: AI visibility isn't the same as AI retrieval. A company can have a high-level brand showing up in ChatGPT while its detailed API docs are poorly retrievable by coding agents. Research this year is finding that AI agents consume documentation very differently from humans, making traditional pageviews and click paths poor indicators of actual AI usage. arxiv.org

If you tell me what kind of technical docs you produce (API docs, SDK docs, product manuals, developer portal, etc.) and where they're hosted (GitBook, ReadMe, Mintlify, custom, etc.), I can narrow this down to the 2–3 tools I'd actually pilot and what metrics I'd require from them.

Yes. If your goal is specifically “which of our technical docs are AI assistants actually using, and what should we change so they answer questions better?”, there are a few different categories of tools.

Best fit: Mintlify

Mintlify is probably the closest off-the-shelf match I found.

Its analytics can distinguish AI-agent traffic from human traffic, and its Assistant analytics show queries, responses, and the sources retrieved. You can export that data and analyze things like:

• Which docs are being retrieved/cited most often
• Which user questions aren't getting good answers
• Content gaps
• Frequently asked questions that need new documentation
• High-traffic pages that need accuracy improvements
• Queries where the assistant couldn't find useful sources mintlify.com

It also has an API for semantic/keyword searching across your docs, which could be useful if you want to build your own analysis layer. www.mintlify.com

But there's an important distinction

If by “used by AI assistants” you mean:

“Show me that ChatGPT, Claude, Gemini, Cursor, Perplexity, etc. are accessing/citing these specific pages across the public internet.”

That's a harder problem. Traditional web analytics don't capture the full picture. AI agents can retrieve documentation in very different ways, and research in 2026 suggests that conventional metrics like session depth and time-on-page aren't reliable indicators of AI consumption. arxiv.org

So I'd think about the tooling as three layers:

What I'd actually build for a technical-docs team

I'd create a “AI Documentation Auditor” that periodically takes your entire documentation corpus and runs a representative set of questions through several models/agents.

For each question, it would record:

Question → AI answer → cited/retrieved docs → correctness → missing information → recommended doc changes

Then aggregate that back to the page level:

authentication/oauth.md

• Retrieved by: 37/100 test questions
• Correctly cited: 31
• Incorrect/partial answers: 6
• Missing context detected: 4
• Duplicate/conflicting information: 2
• Recommended changes:
  • Add explanation of token expiration
  • Explicitly distinguish OAuth vs API-key authentication
  • Add example for refresh-token flow
  • Link to rate-limit documentation

That gives your writers something much more actionable than “this page got 2,400 views.”

Mintlify is moving in this direction itself: its AI-native documentation tooling includes AI traffic analytics, assistant insights, and an agent that can propose documentation changes. www.mintlify.com

If you're evaluating tools to buy rather than build, I'd start with Mintlify. If you tell me where your docs currently live (GitHub/MDX, ReadMe, Docusaurus, Confluence, Zendesk, etc.), I can identify the best 3–5 tools specifically for your stack and compare their AI-citation tracking, doc-gap analysis, automated recommendations, and pricing.

If you mean “which of our docs are AI assistants actually using, where they fail, and what should we improve?”, you’re looking for AI documentation analytics / AI answer intelligence rather than a traditional docs analytics tool.

Some good options:

For a technical documentation team, I’d evaluate tools against these capabilities:

1. AI query mining
   • “What are developers asking AI assistants?”
   • “Which topics generate repeated questions?”

2. Answer attribution
   • Which pages/chunks are retrieved?
   • Which docs are ignored despite being relevant?

3. Coverage gap detection
   • Questions with no good answer
   • Answers requiring multiple docs stitched together
   • Conflicting documentation

4. AI-readiness scoring
   • Are pages structured for retrieval?
   • Are examples, parameters, prerequisites, and edge cases explicit?
   • Are headings and metadata meaningful?

5. Feedback loop
   • Convert AI failures into documentation tickets automatically.

A common architecture is:

Docs repository
      ↓
AI retrieval layer (RAG)
      ↓
User questions from chatbot / IDE agents / support
      ↓
Analytics:
  - top questions
  - failed answers
  - missing docs
  - confusing docs
      ↓
Docs backlog

If you already have your own docs site and don’t want to replace it, I’d start by adding an AI assistant layer (for example Kapa) and using its query analytics to drive your docs roadmap. www.kapa.ai

A useful question for choosing the right tool: are you trying to optimize docs for (a) customers using your website AI assistant, (b) ChatGPT/Claude-style external assistants discovering your docs, or (c) coding agents like Cursor/Copilot consuming your docs? The best tooling differs for each.

Yes. What you’re describing is essentially AI-search / AI-citation analytics for technical documentation: identify which of your pages are being retrieved/cited by AI assistants, what questions they answer, where your coverage is weak, and what to change.

A few tools are worth looking at:

For technical documentation specifically, I'd investigate Kapa first. It is built around technical docs rather than generic marketing content and explicitly provides analytics around questions, missing answers, and which sources are driving successful answers. www.kapa.ai

But there's an important distinction

If by "which docs are used by AI assistants" you mean:

"When someone asks ChatGPT/Claude/Gemini/Perplexity about our product, which exact documentation URLs do those assistants cite?"

That's a somewhat different problem. You want AI citation monitoring, not merely an AI chatbot for your docs.

I'd want a system that produces something like:

Query: "How do I authenticate with Acme API?"

ChatGPT       → /docs/authentication        ✓ cited
Claude        → /docs/api/auth               ✓ cited
Perplexity    → /guides/api-authentication   ✓ cited
Gemini        → competitor documentation     ✗

Your coverage: 75%

Opportunity:
  /docs/authentication is frequently retrieved,
  but doesn't explain OAuth refresh tokens.

Suggested change:
  Add "Refresh-token flow" section + code example.

And ideally it should also identify docs that AI assistants consistently use but humans rarely visit, important questions for which your docs aren't cited, competitor pages being cited instead, and specific content/structure changes likely to improve retrieval.

That's increasingly important because traditional documentation analytics can miss AI consumption: AI agents may retrieve one or two pages rather than navigating through a site, making metrics such as session depth and bounce rate much less meaningful. arxiv.org

If you're evaluating/building a solution for your documentation team, I can also give you a 2026 comparison of the best tools specifically for measuring AI usage/citations of technical docs, including what each actually measures and whether it can identify the exact URL/section an AI used.

If you mean “which of our technical docs are being consumed by AI assistants (ChatGPT, Claude, Copilot, Cursor, etc.), and how do we improve them for AI retrieval and answers?”, the tooling category is still emerging. There are a few approaches:

For a technical documentation team, I’d look for these capabilities specifically:

1. AI citation analytics
   • “Which pages are being cited in AI answers?”
   • “Which docs are never retrieved?”

2. Question-to-doc gap analysis
   • Cluster unanswered questions.
   • Detect repeated prompts where the AI cannot find a good source.

3. Retrieval quality testing
   • Generate hundreds of realistic developer questions.
   • Measure whether the right page/chunk is retrieved.

4. AI readability scoring
   • Detect issues like:
     • overly narrative explanations
     • missing examples
     • unclear API parameters
     • poor headings
     • version ambiguity
     • duplicated/conflicting instructions

5. Freshness checks
   • Compare docs against code/API schemas/releases.
   • Flag stale examples and deprecated workflows.

A practical stack many technical doc teams are moving toward:

• Docs platform (GitBook, Mintlify, ReadMe, Docusaurus, custom docs site)
• Analytics layer (AI query logs + search analytics)
• Evaluation harness (synthetic questions + retrieval scoring)
• LLM reviewer (agent that proposes edits)

If your docs are mainly API/developer docs, I would prioritize an evaluation pipeline over a generic analytics product: the key question is not just “are AI assistants reading our docs?” but “when an AI assistant answers a developer, did it retrieve the correct section and produce the right implementation guidance?”

I can also suggest a shortlist of tools specifically for API docs teams vs enterprise internal knowledge bases if that’s your use case.

Yes. What you’re describing is essentially AI-search / LLM visibility analytics for technical documentation: which pages AI assistants retrieve or cite, for which questions, where your docs lose to competitors, and what content changes would improve coverage.

A few tools are particularly relevant:

Best fits

1. Mintlify — best if you also want to host/manage the technical docs

Its Assistant provides query and source data, including frequently asked questions, content gaps, unsuccessful interactions, and popular topics. You can export the queries/responses/sources for deeper analysis. mintlify.com
It also has a specific GEO guide for optimizing documentation for ChatGPT, Perplexity, Google AI Overviews, etc. www.mintlify.com

2. Documentation.AI — probably closest to your specific requirement

Its Ask AI Analytics tracks questions, sessions, low-confidence answers, satisfaction, recent questions, and page context. That lets you identify where users are asking questions that your documentation isn't answering well. documentation.ai

3. AI-search/GEO monitoring tools — better if you mean external assistants rather than an AI assistant embedded in your docs.

The important metric here is essentially citation share: give ChatGPT/Claude/Gemini/Perplexity a controlled set of questions and measure:

• Does your company appear?
• Which of your URLs get cited?
• Which competitor URLs get cited instead?
• What claims are being extracted from your pages?
• What questions produce no useful citation?
• Which docs should be rewritten/created?

The distinction I'd make

If your question is:

"Which of our docs are users actually using with our documentation chatbot?"

I'd look at Mintlify or Documentation.AI.

If it's:

"When someone asks ChatGPT/Claude/Perplexity about our product, which of our docs do they cite, and how do we get more of our docs cited?"

That's a different category—AI visibility/GEO analytics. I would not rely on llms.txt alone. For example, Mintlify supports llms.txt/llms-full.txt to make documentation easier for LLMs to consume, but that is primarily an ingestion/discoverability mechanism, not evidence that assistants are actually citing your pages. mintlify.com

If you're evaluating/building a tool internally

I'd want the dashboard to look something like:

And, importantly, it should generate specific recommendations, e.g.:

/docs/authentication/oauth
Cited in 7% of authentication-related AI answers despite ranking highly in your docs search.
Problem: The page explains OAuth conceptually but doesn't explicitly answer "How do I refresh an expired access token?"
Recommendation: Add a dedicated "Refresh an access token" section with request/response examples and link it from the OAuth overview.

That is much more valuable than simply saying "make your headings more AI-friendly."

If you tell me where your technical docs live (GitHub/Markdown, ReadMe, GitBook, Docusaurus, Mintlify, Confluence, etc.), I can recommend the best 3–5 tools for your exact setup, including which ones can actually measure ChatGPT/Claude/Perplexity citations rather than just optimize the docs.

If you mean “which of our technical docs are being used by AI assistants (ChatGPT, Claude, Copilot, Perplexity, etc.) and how can we improve them for AI consumption?”, there are a few categories of tools and approaches. There is not yet a single universal “AI documentation analytics” platform, but these are the closest options:

1. AI visibility / AI search analytics tools

These monitor whether your content appears in AI-generated answers and how competitors compare.

• Profound — Tracks brand visibility in AI answers across systems like ChatGPT, Claude, Gemini, and Perplexity. Useful for seeing which pages are surfaced and where gaps exist.
• Peec AI — AI search monitoring focused on visibility, citations, and competitive analysis.
• Scrunch AI — Helps organizations understand how they appear in AI search results.

These are more marketing-oriented, but they can reveal which documentation pages are being cited or referenced by AI systems.

2. Documentation analytics + AI optimization

If you already have a docs platform, these can help identify high-value content and improve structure.

• Mintlify — Developer documentation platform with analytics and AI-focused documentation generation features.
• ReadMe — API documentation platform with analytics around developer usage.
• GitBook — Documentation platform with AI features and usage insights.

Useful signals:

• pages with high human traffic but poor AI retrieval
• outdated API references
• missing examples
• unclear terminology
• fragmented concepts spread across multiple pages

3. Build your own “AI documentation intelligence” pipeline

Many technical teams are building internal versions because AI usage data is hard to obtain.

A typical stack:

1. Collect documentation signals
   • Docs analytics (page views, searches, failed searches)
   • Git history (stale pages, frequent edits)
   • Support tickets
   • Developer forum questions
   • API logs

2. Run AI evaluation

Use an LLM to score docs for:

• “Can an AI answer common developer questions from this page?”
• “Are examples complete?”
• “Are prerequisites explicit?”
• “Is terminology consistent?”
• “Does this page contain authoritative facts?”

3. Measure retrieval quality

Build a test set:

• 100–500 real user questions
• expected answers
• relevant documentation URLs

Then evaluate:

• Did the AI find the right page?
• Did it hallucinate?
• Was the answer complete?

Tools often used:

• LangSmith
• Arize Phoenix
• Ragas

4. What improvements usually make docs better for AI assistants

AI systems tend to perform better when docs have:

✅ One concept per page
Avoid giant “everything guides.”

✅ Explicit definitions
Bad:

Authentication uses OAuth.

Better:

OAuth is the authorization protocol used by our API. It allows applications to obtain an access token that is sent in the Authorization: Bearer header.

✅ Question-oriented headings
Instead of:

Authentication

Use:

How do I authenticate API requests?

✅ Complete examples
Include:

• request
• response
• errors
• edge cases
• prerequisites

✅ Stable URLs
AI systems rely heavily on indexed references.

✅ Machine-readable structure

• clear Markdown
• tables
• code blocks
• metadata
• version information

If you are producing technical docs, a strong setup is usually:

Docs platform analytics
→ identify important/poorly performing pages
→ AI evaluation harness
→ test against real developer questions
→ AI visibility monitoring
→ measure whether improvements increase citations/retrieval

If you tell me your current stack (for example: GitHub Markdown, Docusaurus, ReadMe, Confluence, GitBook, OpenAPI docs, etc.) and whether you care about ChatGPT citations, internal enterprise copilots, or developer self-service, I can suggest a more specific toolchain.

If your goal is specifically "optimize our documentation so AI assistants (ChatGPT, Claude, Gemini, Copilot, Cursor, etc.) can answer questions from it more accurately," this is an emerging category often called LLM documentation analytics or AI documentation optimization.

The tools fall into a few groups:

For understanding what AI assistants are actually using, newer tools are appearing:

These are closer to an "SEO for AI" approach than documentation quality analysis.

If you want repository-level analysis

If your docs live in GitHub, Confluence, or Markdown repositories, there are AI-powered tools that can analyze the documentation itself:

• Cursor can scan an entire documentation repository and identify inconsistencies, missing examples, and outdated sections.
• Sourcegraph Cody understands code and documentation together and can surface documentation gaps.
• GitBook AI analyzes documentation collections and improves discoverability.

If your goal is "How well can AI answer from our docs?"

This is the capability I'd recommend evaluating. An ideal system should:

• Crawl all documentation.
• Ask hundreds or thousands of representative questions.
• Measure:
  • answer accuracy
  • hallucination rate
  • citation quality
  • missing information
• Identify which pages contribute to successful answers.
• Highlight documentation that is rarely used or never cited.
• Suggest concrete edits such as:
  • adding prerequisites
  • improving headings
  • splitting long pages
  • adding examples
  • filling conceptual gaps
  • improving API parameter descriptions

This is closer to RAG evaluation than traditional documentation analytics.

Enterprise options

If you're building an AI assistant over your own technical documentation, consider:

• LangSmith for evaluating retrieval quality and answer accuracy.
• LlamaCloud for ingestion, indexing, and retrieval evaluation.
• Weights & Biases Weave for LLM application evaluation and tracing.
• Arize Phoenix for observability and RAG evaluation.

These platforms can reveal which documents are retrieved, whether retrieval is correct, and which questions fail due to missing or poorly structured documentation.

For a company with a substantial documentation set (hundreds or thousands of pages), I'd generally combine:

• Inkeep for real user question analytics,
• LangSmith or Arize Phoenix for automated evaluation,
• Profound or Scrunch AI for external AI visibility.

That combination provides insight into both how your internal AI assistant uses your documentation and how public AI assistants reference your content.

If you mean “which parts of our technical documentation are being used by AI assistants (ChatGPT, Claude, Copilot, etc.) and how should we improve them for AI consumption”, there are a few categories of tools. The right choice depends on whether you want usage analytics, AI visibility tracking, or documentation quality optimization.

1. AI search / answer visibility tools (best for “are AIs using our docs?”)

• Scrunch AI — Tracks how brands and content appear in AI-generated answers and helps identify opportunities to improve visibility.
• Profound — Monitors how companies appear in AI search and assistant responses, including competitive analysis.
• Otterly.AI — Tracks mentions and visibility across AI search engines.

These are more focused on AI discoverability than technical documentation specifically, but they can reveal whether your docs are being surfaced.

2. Documentation platforms with AI analytics

If your docs live in a modern documentation platform, look for AI-related analytics:

• Mintlify — Developer documentation platform with AI-friendly docs generation and optimization features.
• ReadMe — API documentation platform with analytics around documentation usage and developer engagement.
• GitBook — Documentation platform with AI-assisted writing and knowledge management features.

These can tell you:

• which pages developers read,
• where users drop off,
• which topics need clarification,
• which docs are likely to become AI retrieval sources.

3. Tools for improving docs for AI retrieval (RAG / assistants)

If your goal is “make our docs better input material for AI assistants”, look at:

• LangSmith — Helps evaluate AI applications and retrieval quality. Useful if you have an internal assistant trained on your docs.
• Arize Phoenix — Observability and evaluation for AI systems, including retrieval performance.
• LlamaIndex — Framework for building and evaluating document-based AI assistants.

These help answer questions like:

• Did the assistant retrieve the correct document?
• Was the answer grounded in our docs?
• Which documents are missing or ambiguous?
• Which chunks are poor retrieval candidates?

4. Build-your-own “AI documentation audit” pipeline

Many technical teams build a lightweight internal system:

1. Crawl docs (Markdown, Confluence, GitBook, PDFs)
2. Split into retrieval chunks
3. Run test questions (“How do I authenticate?”, “How do I handle rate limits?”)
4. Measure:
   • retrieval accuracy,
   • unanswered questions,
   • outdated pages,
   • duplicate/conflicting guidance
5. Generate improvement tickets

Useful components:

• OpenAI API platform for evaluations and assistants
• Pinecone or Weaviate for vector search testing

What I would evaluate for a technical documentation team

A practical stack:

A key distinction: you generally cannot see exactly which private ChatGPT/Claude conversations used your docs. What you can measure is:

• whether your public docs are discoverable by AI systems,
• whether AI crawlers can access them,
• whether retrieval-based assistants answer correctly using them,
• where documentation gaps exist.

If you mean internal enterprise AI assistants (Copilot, ChatGPT Enterprise, Claude Enterprise, etc.) using your private docs, the tool choice is different.

If your goal is "optimize our technical documentation so AI assistants (ChatGPT, Claude, Gemini, Copilot, etc.) use it more often and answer from it more accurately," there are now several categories of tools. They solve slightly different problems.

1. AI documentation analytics (closest to what you're asking)

These tools analyze your documentation, identify gaps, and often simulate AI retrieval.

• Mintlify
  • AI-powered documentation platform
  • Can identify missing topics, weak pages, broken information architecture, and search issues
  • Includes AI chat over docs, giving insight into what users (and AI) struggle to find

• Inkeep
  • Tracks what AI assistants retrieve
  • Shows unanswered questions
  • Highlights documentation gaps
  • One of the better products if your docs are part of an AI support workflow

• Stainless
  • Focused on API documentation
  • Validates OpenAPI specs
  • Helps generate AI-friendly SDKs and docs
  • Optimizes documentation for developer assistants

2. LLM evaluation tools

These don't analyze writing quality as much as whether an AI can answer questions correctly from your docs.

Examples include:

• Langfuse
• Arize AI
• TruEra

Typical workflow:

1. Ask 500–5,000 realistic developer questions.
2. Retrieve documentation.
3. Have an LLM answer.
4. Measure:
   • retrieval success
   • hallucination rate
   • citation quality
   • answer completeness
5. Report which pages need improvement.

This is often the most actionable approach.

3. Search analytics

If your docs have built-in search:

• Algolia Analytics
• Elastic Search Analytics
• Typesense Analytics

These reveal:

• searches with no results
• searches that end in abandonment
• popular topics
• missing terminology

These signals often align with where AI assistants also struggle.

4. AI crawl/readiness analysis

A newer category focuses on whether AI systems can easily consume your content.

They check things like:

• page structure
• semantic headings
• duplicate content
• canonical URLs
• machine-readable navigation
• API references
• schema markup
• llms.txt support
• chunkability

This is similar to SEO tooling, but optimized for LLM consumption.

5. Build your own evaluation pipeline (recommended for larger doc sets)

Many documentation teams now build automated "AI doc quality" testing.

For each page:

• Generate 20–100 questions users might ask.
• See whether an AI retrieves that page.
• Measure:
  • confidence
  • completeness
  • missing prerequisites
  • ambiguity
  • conflicting pages
• Produce improvement suggestions.

This can be run nightly as part of CI/CD.

What I'd recommend

If you produce a substantial set of developer or technical documentation, a combination tends to work best:

The most effective setups don't just score readability—they test whether real AI assistants can successfully retrieve the right documentation and generate correct answers. That produces concrete recommendations such as adding missing examples, clarifying terminology, restructuring headings, or filling gaps that prevent accurate AI-generated responses.

If you mean technical documentation that is consumed by AI assistants (RAG systems, chatbots, coding copilots, support agents, etc.), you’re looking for a mix of documentation analytics + AI retrieval evaluation + content optimization tools. There isn’t one universal “AI assistant doc analyzer,” but these categories cover the problem:

Tools worth evaluating

• LangSmith

Good for teams building RAG assistants. It can trace retrieval steps, show which documents/chunks were used, evaluate responses, and help identify retrieval failures.

• Arize Phoenix

Open-source observability for LLM applications. Useful for seeing retrieved context, hallucinations, and document relevance.

• Langfuse

Open-source LLM analytics platform for tracing prompts, retrieval, and user interactions.

• Weights & Biases Weave

Useful for evaluating and monitoring AI applications.

• Glean

Enterprise search/knowledge assistant platform. Helpful if you want analytics around what internal knowledge sources are being used.

• Google Cloud Vertex AI Evaluation

Provides evaluation workflows for generative AI systems.

For documentation-specific improvement

If your docs are in a documentation platform, look at:

• Document360 — knowledge base analytics and AI features.
• GitBook — docs platform with AI-assisted documentation workflows.
• Confluence — useful if your docs are internal and connected to enterprise AI search.

A practical setup for a technical documentation team

A mature workflow usually looks like:

1. Collect AI queries
   • Questions users ask your assistant/copilot
   • Support tickets
   • Search logs

2. Measure retrieval
   • Which docs/chunks were retrieved?
   • Were the right docs selected?
   • Were answers cited correctly?

3. Score gaps
   • “The API authentication docs were retrieved but missing OAuth examples”
   • “Users ask about migration but no migration guide exists”
   • “Terminology differs between docs and user questions”

4. Create improvement backlog
   • Add missing examples
   • Improve headings and metadata
   • Split overly long pages
   • Add canonical answers for common AI queries

If you already have an AI assistant connected to your docs, the best first tool depends on what stack you use (for example: GitHub + Markdown, Confluence, GitBook, ReadMe, Docusaurus, Zendesk, or a custom RAG system). I can suggest a more targeted setup if you share your documentation platform and whether you control the AI assistant.

If your goal is to optimize technical documentation so AI assistants (ChatGPT, Claude, Gemini, Copilot, etc.) can retrieve and answer from it more effectively, there are a few categories of tools. No single tool perfectly tells you "this document is used by AI assistants," but several can analyze AI readiness and identify gaps.

Here are the strongest options:

For AI-specific optimization, these are especially useful:

1. Inkeep (probably closest to what you're asking)

If you have an AI assistant over your docs, Inkeep provides insights such as:

• Questions AI couldn't answer
• Documents frequently retrieved
• Missing documentation
• Hallucination hotspots
• Suggested new articles

This is one of the few products designed specifically around AI documentation quality.

2. Mintlify

Mintlify's documentation platform includes:

• AI readability analysis
• Documentation completeness
• SEO and LLM optimization
• Detection of weak pages
• Recommendations for restructuring

3. Build your own "AI doc evaluator"

Many documentation teams create an evaluation pipeline using an LLM. For each page, they automatically score things like:

• Can an AI answer questions from this page?
• Is terminology defined?
• Are prerequisites clear?
• Are examples complete?
• Is the page self-contained?
• Could another page be merged or split?
• Would retrieval likely confuse this with another document?

This often produces a scorecard such as:

Many companies automate this for thousands of documents.

4. Measure retrieval directly

The most effective approach is to evaluate your documentation as an AI system would:

1. Generate hundreds or thousands of realistic user questions.
2. Run retrieval against your documentation.
3. Check whether the correct document is retrieved.
4. Have an LLM grade the answer for accuracy and completeness.
5. Report which documents consistently fail.

This identifies documents that are difficult for AI assistants to use, even if they read well to humans.

If you're producing developer documentation

A strong modern stack is:

• Docs platform: Mintlify or ReadMe
• Analytics: Inkeep
• Search: Algolia
• Evaluation: An automated LLM-based evaluation pipeline (using models from providers such as OpenAI or Anthropic) that regularly scores documentation quality and retrieval performance.

That combination gives you both usage insights and actionable recommendations for improving documentation so AI assistants can answer accurately from it.