SUPERCHARGE YOUR ONLINE VISIBILITY! CONTACT US AND LET’S ACHIEVE EXCELLENCE TOGETHER!
Artificial intelligence infrastructure becomes valuable only when it solves a real problem.
An organisation may have:
- a knowledge graph
- an entity registry
- a vector database
- AI answer primitives
- ranking models
- decision rules
- feedback systems
- retrieval pipelines
- AI agents
- APIs
- structured datasets
But another question remains:
Where should each capability actually be used?
An AI system may be technically capable of summarisation, retrieval, recommendation, classification, decision support, automation and reasoning.
That does not mean every capability should be used in every situation.
A customer-support assistant needs different information from a sales recommendation engine.
An AI citation-monitoring workflow has different requirements from an ecommerce product recommendation system.
A healthcare information assistant may require stronger controls than an internal content ideation tool.
An enterprise therefore needs a machine-readable way to define:
- the problem being solved
- who the user is
- what the user wants
- which AI capabilities are relevant
- what information is required
- what inputs are necessary
- which resources should be retrieved
- which decisions are permitted
- which actions can be automated
- what limitations apply
- how success should be measured
That is the purpose of ai-use-cases.json.
In simple terms:
ai-use-cases.json defines where, why and how AI capabilities should be applied to specific business, search, knowledge and operational scenarios.
The file can potentially act as a structured catalogue connecting AI infrastructure to practical applications.
It can describe:
- use-case identities
- business goals
- user personas
- user intents
- triggers
- required inputs
- required knowledge
- AI capabilities
- retrieval requirements
- answer requirements
- ranking requirements
- decision requirements
- tools
- actions
- automation levels
- risk levels
- constraints
- escalation paths
- success metrics
- expected outputs
- supporting resources
- feedback requirements
- governance
The objective is not simply to create a list of things AI can do.
The objective is to define when a particular AI capability should be used and what a successful implementation should look like.
What Is ai-use-cases.json?
ai-use-cases.json is a proposed machine-readable JSON resource for describing AI application scenarios.
Each use case can represent a specific combination of:
- user
- objective
- context
- inputs
- knowledge
- AI capabilities
- workflow
- output
- decision logic
- constraints
- measurement
A simple use case might look like this:
{
“useCaseId”: “use-case:ai-search:brand-visibility”,
“name”: “AI Brand Visibility Analysis”,
“objective”: “Evaluate how accurately and frequently a brand appears across monitored AI answer environments.”,
“users”: [
“SEO team”,
“AI visibility team”,
“brand team”
],
“capabilities”: [
“query monitoring”,
“entity recognition”,
“citation analysis”,
“answer evaluation”
],
“expectedOutputs”: [
“brand mention status”,
“entity accuracy”,
“citation presence”,
“competitor comparison”
]
}
This object does not contain every detail about the brand.
It does not define the entire ranking system.
It does not make the final business decision.
Instead, it describes the application scenario in which those other resources may be used.
Why AI Systems Need Use-Case Definitions
AI projects often begin with technology.
For example:
We should implement RAG.
or:
We need an AI agent.
or:
We should build a chatbot.
These statements describe technologies, not necessarily business problems.
A better starting point is:
Which problem are we solving?
For example:
Customers repeatedly ask questions that already exist in product documentation, but support agents spend significant time locating the correct information.
Now the use case becomes clearer.
Possible solution:
Documentation Retrieval
+
RAG
+
Answer Generation
+
Citation Support
The technology follows the use case.
A structured use-case layer helps organisations move from:
AI capability
to:
Business objective
↓
Appropriate AI capability
↓
Governed implementation
AI Capability vs AI Use Case
These concepts should not be confused.
AI Capability
Describes what a system can do.
Examples:
- summarise
- classify
- retrieve
- generate
- translate
- recommend
- rank
- compare
- extract
- reason
- automate
AI Use Case
Describes why and where that capability is applied.
For example:
Capability
Classification
Use Case
Classify incoming customer-support requests into billing, technical, account and security categories.
Another:
Capability
Semantic Retrieval
Use Case
Retrieve the most relevant enterprise documentation for an employee question.
Capabilities are reusable functions.
Use cases are practical applications.
ai-use-cases.json Within the AI Stack
A machine-readable AI ecosystem can contain several specialised resources.
entity-registry.json
Answers:
What entities exist?
It defines:
- organisations
- products
- people
- services
- concepts
- aliases
- canonical IDs
It is identity-first.
knowledge-graph.json
Answers:
How are the entities connected?
It defines:
- relationships
- ownership
- authorship
- dependencies
- semantic associations
It is relationship-first.
brand-memory.json
Answers:
What should the system remember about the organisation?
It defines:
- organisational identity
- expertise
- products
- frameworks
- people
- research
It is memory-first.
context-engine.json
Answers:
What matters in this specific situation?
It identifies:
- user type
- market
- intent
- location
- stage
- environment
It is context-first.
ai-ranking-model.json
Answers:
Which candidate should receive the greatest priority?
It ranks:
- sources
- documents
- entities
- answers
- citations
- recommendations
It is priority-first.
ai-answer-primitives.json
Answers:
What reusable knowledge can contribute to the answer?
It defines:
- facts
- definitions
- comparisons
- limitations
- procedures
It is answer-first.
reasoning-map.json
Answers:
How are concepts or evidence connected through reasoning paths?
It is reasoning-first.
ai-decision-layer.json
Answers:
What should happen given the current evidence and context?
It defines:
- rules
- actions
- recommendations
- abstention
- escalation
It is decision-first.
ai-feedback-loop.json
Answers:
Did the outcome perform well and what should improve?
It is improvement-first.
ai-use-cases.json
Answers:
In which real-world scenario should these AI capabilities and resources be used?
It is application-first.
The complete architecture can therefore resemble:
BUSINESS NEED
↓
USE CASE
↓
CONTEXT
↓
IDENTITY
↓
KNOWLEDGE
↓
RETRIEVAL
↓
RANKING
↓
ANSWER
↓
REASONING
↓
DECISION
↓
ACTION
↓
FEEDBACK
The Use Cases layer gives the entire architecture a purpose.
The Core Role of ai-use-cases.json
The file can answer five fundamental questions.
1. Who?
Who is the AI serving?
Examples:
- customer
- employee
- developer
- marketer
- researcher
- support agent
- sales representative
- website visitor
2. What?
What task needs to be completed?
Examples:
- answer a question
- compare products
- retrieve documentation
- qualify a lead
- analyse brand visibility
- detect content gaps
3. Why?
What business or user objective does the task support?
Examples:
- reduce support time
- improve answer accuracy
- increase conversion
- improve AI visibility
- reduce research effort
4. How?
Which AI capabilities and resources should be used?
Examples:
- RAG
- knowledge graph
- ranking model
- answer primitives
- decision rules
- external search
5. How Do We Know It Worked?
What metrics define success?
Examples:
- answer accuracy
- task completion
- conversion rate
- response time
- escalation reduction
- citation rate
Core Use-Case Architecture
A structured AI use case may follow:
Problem
↓
User
↓
Goal
↓
Trigger
↓
Inputs
↓
Context
↓
Required Knowledge
↓
AI Capabilities
↓
Workflow
↓
Decision
↓
Output
↓
Action
↓
Success Metric
↓
Feedback
Each stage helps make the AI application more explicit.
Recommended File Location
A straightforward public implementation could use:
https://example.com/ai-use-cases.json
Alternative locations may include:
https://example.com/.well-known/ai-use-cases.json
or:
https://example.com/ai/ai-use-cases.json
An organisation could also maintain internal use-case resources through:
- APIs
- MCP servers
- enterprise knowledge systems
- internal documentation
- AI orchestration platforms
Some use cases may contain confidential business logic and should not be published publicly.
Recommended MIME Type
Serve the file as:
application/json
Recommended HTTP response:
HTTP/1.1 200 OK
Content-Type: application/json; charset=utf-8
Useful technical conditions include:
- valid JSON
- UTF-8 encoding
- stable use-case IDs
- version information
- last-updated metadata
- canonical entity references
- valid related-resource links
- clear status fields
- governance information
Recommended Top-Level Structure
A mature implementation could include:
{
“metadata”: {},
“organization”: {},
“capabilityRegistry”: {},
“userTypes”: [],
“useCaseCategories”: [],
“useCases”: [],
“riskModel”: {},
“automationPolicy”: {},
“successMetrics”: {},
“relatedResources”: {},
“governance”: {}
}
Field-by-Field Explanation
metadata
Defines the file itself.
Example:
{
“metadata”: {
“version”: “2026.1”,
“fileType”: “ai-use-cases”,
“generatedAt”: “2026-09-03”,
“lastUpdated”: “2026-09-03”,
“language”: “en”,
“publisher”: “ThatWare LLP”,
“canonicalUrl”: “https://thatware.co/ai-use-cases.json”,
“description”: “Machine-readable catalogue describing AI application scenarios, required capabilities, workflows, constraints and expected outcomes.”
}
}
Metadata supports:
- versioning
- governance
- freshness
- discovery
- auditing
organization
Defines who owns the use-case framework.
{
“organization”: {
“id”: “entity:organization:thatware”,
“name”: “ThatWare”,
“legalName”: “ThatWare LLP”,
“url”: “https://thatware.co/”
}
}
useCaseId
Each use case should have a stable unique identifier.
Example:
{
“useCaseId”: “use-case:geo:brand-monitoring”
}
A useful naming pattern may be:
use-case:<domain>:<purpose>
Examples:
use-case:customer-support:question-answering
use-case:geo:brand-monitoring
use-case:content:knowledge-gap-detection
use-case:sales:lead-qualification
use-case:enterprise:document-retrieval
Stable IDs support:
- versioning
- testing
- references
- reporting
- integrations
name
Provide a human-readable name.
Example:
{
“name”: “AI Brand Visibility Monitoring”
}
description
Explain the use case clearly.
Example:
{
“description”: “Monitor how a brand, its services and its associated entities are represented within selected AI-generated answer environments.”
}
A good description should identify the application rather than simply repeating the use-case name.
problemStatement
A strong use case begins with the problem.
Example:
{
“problemStatement”: “The organisation lacks consistent visibility into how accurately its brand is represented across AI-generated answers.”
}
This field prevents use cases from becoming technology-led.
objective
Defines the intended result.
{
“objective”: “Identify AI representation gaps and prioritise authoritative content or entity improvements.”
}
Objectives should ideally be measurable.
businessValue
Describes why the use case matters.
{
“businessValue”: [
“improve AI brand visibility”,
“identify misinformation”,
“prioritise GEO actions”,
“monitor competitor representation”
]
}
userTypes
Defines who interacts with or benefits from the system.
{
“userTypes”: [
“SEO strategist”,
“AI visibility analyst”,
“brand manager”
]
}
User type influences:
- language
- permissions
- outputs
- available tools
- risk
- interface
userIntent
Defines what the user is trying to accomplish.
Example:
{
“userIntent”: “Determine why the brand is not appearing for important generative search queries.”
}
trigger
Defines when the use case begins.
Example:
{
“trigger”: {
“type”: “scheduled”,
“frequency”: “weekly”
}
}
Other triggers may include:
user_query
new_document
new_lead
support_request
content_update
ranking_change
AI_visibility_change
workflow_event
inputs
Defines information required by the workflow.
Example:
{
“inputs”: {
“required”: [
“brandEntity”,
“targetQueries”
],
“optional”: [
“competitors”,
“markets”,
“targetPlatforms”
]
}
}
contextRequirements
Defines context that should be resolved before execution.
{
“contextRequirements”: [
“market”,
“language”,
“userIntent”
]
}
This can connect directly with context-engine.json.
knowledgeRequirements
Defines what knowledge is necessary.
Example:
{
“knowledgeRequirements”: [
“brand identity”,
“service definitions”,
“canonical URLs”,
“competitor entities”
]
}
capabilities
Defines AI functions used in the workflow.
Example:
{
“capabilities”: [
“semantic retrieval”,
“entity recognition”,
“classification”,
“ranking”,
“summarisation”
]
}
requiredResources
Connects the use case with other machine-readable infrastructure.
Example:
{
“requiredResources”: [
“entity-registry.json”,
“ai-answer-primitives.json”,
“ai-ranking-model.json”
]
}
workflow
Describes major stages.
{
“workflow”: [
“receive query”,
“resolve entities”,
“retrieve relevant knowledge”,
“rank candidates”,
“generate grounded answer”,
“capture feedback”
]
}
expectedOutput
Defines what the AI should produce.
Example:
{
“expectedOutput”: {
“type”: “analysis_report”,
“contains”: [
“brand visibility”,
“entity accuracy”,
“citation presence”,
“competitor comparison”
]
}
}
decisionRequirements
Some use cases involve decisions.
Example:
{
“decisionRequirements”: [
“determine whether evidence is sufficient”,
“determine whether human review is required”
]
}
These can connect with ai-decision-layer.json.
actionRequirements
Some workflows take actions.
{
“actions”: [
“create recommendation”,
“open review task”
]
}
For AI agents, actions may be more operational.
automationLevel
Defines how much autonomy is permitted.
Possible values:
informational
assistive
preparatory
human_confirmed
autonomous
Example:
{
“automationLevel”: “assistive”
}
riskLevel
Defines potential impact.
{
“riskLevel”: “low”
}
Possible values:
low
medium
high
critical
constraints
Defines boundaries.
Example:
{
“constraints”: [
“Do not present unverified third-party claims as factual brand information.”,
“Do not infer missing performance data.”
]
}
humanReview
Defines when a person is required.
{
“humanReview”: {
“required”: true,
“when”: [
“high severity misinformation”,
“unresolved evidence conflict”
]
}
}
successMetrics
Defines how performance is evaluated.
Example:
{
“successMetrics”: [
“entity accuracy rate”,
“citation coverage”,
“brand mention coverage”,
“correction rate”
]
}
feedbackRequirements
Defines what should be monitored after the workflow.
{
“feedbackRequirements”: [
“human relevance rating”,
“answer accuracy”,
“repeat error rate”
]
}
This can connect directly with ai-feedback-loop.json.
Complete Example ai-use-cases.json
{
“metadata”: {
“version”: “2026.1”,
“fileType”: “ai-use-cases”,
“generatedAt”: “2026-09-03”,
“lastUpdated”: “2026-09-03”,
“publisher”: “ThatWare LLP”,
“language”: “en”,
“canonicalUrl”: “https://thatware.co/ai-use-cases.json”,
“description”: “Machine-readable catalogue of AI application scenarios, required capabilities, workflows, governance controls and expected outcomes.”
},
“organization”: {
“id”: “entity:organization:thatware”,
“name”: “ThatWare”,
“legalName”: “ThatWare LLP”,
“url”: “https://thatware.co/”
},
“capabilityRegistry”: [
“semantic retrieval”,
“entity resolution”,
“ranking”,
“answer generation”,
“classification”,
“recommendation”,
“decision support”,
“summarisation”,
“comparison”,
“monitoring”
],
“useCaseCategories”: [
“AI Search”,
“GEO”,
“AEO”,
“Content”,
“Customer Support”,
“Sales”,
“Enterprise Knowledge”,
“Research”
],
“useCases”: [
{
“useCaseId”: “use-case:geo:brand-visibility-monitoring”,
“name”: “AI Brand Visibility Monitoring”,
“category”: “GEO”,
“problemStatement”: “The organisation needs to understand how accurately and frequently its brand appears across monitored generative answer environments.”,
“objective”: “Identify brand visibility, citation and entity representation gaps.”,
“userTypes”: [
“AI visibility analyst”,
“SEO strategist”,
“brand manager”
],
“inputs”: {
“required”: [
“brandEntity”,
“targetQueries”
],
“optional”: [
“competitors”,
“markets”
]
},
“capabilities”: [
“query monitoring”,
“entity recognition”,
“citation analysis”,
“classification”
],
“requiredResources”: [
“entity-registry.json”,
“brand-memory.json”,
“ai-ranking-model.json”
],
“workflow”: [
“run target queries”,
“capture responses”,
“detect brand entities”,
“analyse citations”,
“compare competitor presence”,
“classify representation gaps”,
“create recommendations”
],
“expectedOutputs”: [
“brand mention coverage”,
“entity accuracy”,
“citation coverage”,
“competitor visibility”,
“recommended optimisation actions”
],
“automationLevel”: “assistive”,
“riskLevel”: “low”,
“successMetrics”: [
“brand representation accuracy”,
“query coverage”,
“citation visibility”
],
“feedbackRequired”: true
},
{
“useCaseId”: “use-case:aeo:direct-answer-generation”,
“name”: “Direct Answer Generation”,
“category”: “AEO”,
“problemStatement”: “Users need concise, evidence-backed answers without navigating multiple documents.”,
“objective”: “Generate accurate direct answers from authoritative knowledge.”,
“capabilities”: [
“semantic retrieval”,
“answer primitive retrieval”,
“reranking”,
“answer generation”,
“citation selection”
],
“requiredResources”: [
“ai-answer-primitives.json”,
“ai-ranking-model.json”,
“entity-registry.json”
],
“workflow”: [
“detect intent”,
“resolve entity”,
“retrieve answer primitives”,
“rank candidates”,
“generate answer”,
“attach evidence”
],
“expectedOutputs”: [
“direct answer”,
“supporting explanation”,
“citation”
],
“constraints”: [
“Do not generate unsupported factual claims.”
],
“successMetrics”: [
“answer accuracy”,
“groundedness”,
“citation support rate”
]
},
{
“useCaseId”: “use-case:content:knowledge-gap-detection”,
“name”: “AI Knowledge Gap Detection”,
“category”: “Content”,
“problemStatement”: “Repeated user questions cannot be answered reliably using existing authoritative content.”,
“objective”: “Identify missing knowledge that should be added to the website or knowledge base.”,
“capabilities”: [
“query clustering”,
“answer evaluation”,
“knowledge retrieval”,
“gap classification”
],
“requiredResources”: [
“ai-answer-primitives.json”,
“ai-feedback-loop.json”
],
“workflow”: [
“collect unanswered questions”,
“cluster similar intents”,
“search existing knowledge”,
“identify missing authoritative answers”,
“create content recommendations”
],
“expectedOutputs”: [
“knowledge gaps”,
“recommended content topics”,
“recommended answer primitives”
],
“successMetrics”: [
“reduction in unanswered queries”,
“answer coverage improvement”
]
},
{
“useCaseId”: “use-case:enterprise:knowledge-assistant”,
“name”: “Enterprise Knowledge Assistant”,
“category”: “Enterprise Knowledge”,
“problemStatement”: “Employees spend excessive time searching internal documents for reliable operational information.”,
“objective”: “Provide grounded answers using approved enterprise knowledge.”,
“capabilities”: [
“semantic search”,
“RAG”,
“entity resolution”,
“answer generation”,
“citation selection”
],
“workflow”: [
“receive employee question”,
“identify permissions”,
“retrieve authorised knowledge”,
“rank evidence”,
“generate answer”,
“provide source references”
],
“automationLevel”: “assistive”,
“successMetrics”: [
“time saved”,
“answer accuracy”,
“source utilisation”,
“employee satisfaction”
]
}
],
“automationPolicy”: {
“informational”: {
“executionPermission”: “automatic”
},
“assistive”: {
“executionPermission”: “automatic”
},
“human_confirmed”: {
“executionPermission”: “requires_confirmation”
},
“high_risk”: {
“executionPermission”: “requires_human_review”
}
},
“relatedResources”: {
“entityRegistry”: “https://thatware.co/entity-registry.json”,
“knowledgeGraph”: “https://thatware.co/knowledge-graph.json”,
“brandMemory”: “https://thatware.co/brand-memory.json”,
“answerPrimitives”: “https://thatware.co/ai-answer-primitives.json”,
“rankingModel”: “https://thatware.co/ai-ranking-model.json”,
“decisionLayer”: “https://thatware.co/ai-decision-layer.json”,
“feedbackLoop”: “https://thatware.co/ai-feedback-loop.json”
},
“governance”: {
“reviewUseCasesRegularly”: true,
“requireMetrics”: true,
“requireRiskClassification”: true,
“retireUnusedUseCases”: true
}
}
Recommended AI Use-Case Categories
A large organisation may group use cases into several domains.
AI Search Use Cases
Examples:
- brand monitoring
- AI citation analysis
- generative query tracking
- competitor AI visibility analysis
- entity representation audits
GEO Use Cases
Examples:
- generative visibility gap detection
- citation opportunity identification
- machine-readable content optimisation
- entity authority analysis
AEO Use Cases
Examples:
- direct answer generation
- FAQ coverage
- conversational query matching
- answer primitive selection
SEO Use Cases
Examples:
- content gap analysis
- internal linking recommendations
- SERP intent classification
- technical issue prioritisation
Content Use Cases
Examples:
- topic clustering
- content brief generation
- content refresh detection
- knowledge-gap identification
Sales Use Cases
Examples:
- lead qualification
- service matching
- account research
- proposal assistance
Customer Support Use Cases
Examples:
- question answering
- ticket classification
- troubleshooting
- escalation routing
Enterprise Knowledge Use Cases
Examples:
- internal search
- policy retrieval
- employee onboarding
- document Q&A
Ecommerce Use Cases
Examples:
- product recommendations
- compatibility checks
- product comparisons
- availability assistance
Research Use Cases
Examples:
- literature retrieval
- source comparison
- evidence synthesis
- citation validation
AI Use Cases for GEO and AI Visibility
For ThatWare specifically, ai-use-cases.json can become especially relevant to GEO and AI search analysis.
A GEO use case might define:
User Goal:
Improve brand representation in generative search
↓
Use Case:
AI Visibility Monitoring
↓
Capabilities:
Query tracking
Entity recognition
Citation analysis
Competitor comparison
↓
Outputs:
Visibility score
Citation gaps
Entity errors
Recommended actions
Another use case:
Problem:
AI platforms repeatedly describe a service incorrectly.
↓
Use Case:
Entity Representation Correction
↓
Required Resources:
Entity Registry
Brand Memory
Canonical Service Pages
Answer Primitives
↓
Action:
Identify authoritative content gaps
The use-case file creates an operational bridge between ThatWare’s machine-readable infrastructure and actual GEO activities.
AI Use Cases and RAG
RAG itself is not a use case.
RAG is an architecture.
A use case might be:
Help employees answer policy questions using approved documentation.
RAG becomes the implementation method.
Example:
Use Case
Employee Policy Assistant
↓
Capability
Question Answering
↓
Architecture
RAG
↓
Knowledge
Internal Policy Documents
↓
Ranking
Authority + Relevance + Freshness
↓
Output
Grounded Answer + Citation
This distinction prevents organisations from implementing RAG without a defined purpose.
AI Use Cases and the Ranking Model
The use-case file can specify which ranking model should be used.
Example:
{
“useCaseId”: “use-case:research:evidence-retrieval”,
“rankingModel”: “ranking:research:evidence-first”
}
Another use case may require:
ranking:freshness-sensitive
for current pricing information.
The use case defines the scenario.
The Ranking Model defines candidate priority.
AI Use Cases and Answer Primitives
A direct-answer use case can specify:
Use Case
Definition Q&A
↓
Answer Primitive Type
definition
A comparison workflow may specify:
Answer Primitive Type
comparison
This reduces unnecessary retrieval.
AI Use Cases and the Decision Layer
Some use cases require decisions.
Example:
Use Case:
Service Recommendation
↓
Candidates:
SEO
AEO
GEO
LLM SEO
↓
Ranking:
User fit
↓
Decision Layer:
Determine recommendation
The use-case resource tells the system when the decision workflow applies.
AI Use Cases and the Feedback Loop
Every important use case should ideally define feedback.
Example:
Use Case
Support Assistant
↓
Output
Answer
↓
Feedback
Was the answer correct?
Did the user need escalation?
Was the source useful?
↓
Feedback Loop
Improve future answers
A use case without measurement can become difficult to improve.
AI Use Cases and the Context Engine
Context determines whether the same use case should behave differently.
For example:
Product Recommendation
for:
first-time buyer
may require more explanation.
For:
technical procurement specialist
the system may prioritise specifications.
The Context Engine resolves the situation.
The Use Case determines the workflow.
Public vs Internal AI Use Cases
Some use cases can be public.
Examples:
- website question answering
- AI-search monitoring
- content recommendations
- public information retrieval
Others may contain sensitive logic.
Examples:
- fraud detection
- risk scoring
- internal pricing
- private customer segmentation
- employee performance analysis
- security workflows
An organisation may therefore publish only a high-level use-case catalogue while maintaining operational implementations internally.
Use-Case Eligibility
Not every AI capability should be available for every situation.
A use case may require eligibility rules.
Example:
{
“eligibility”: {
“requiresAuthenticatedUser”: true,
“requiredRole”: [
“employee”
]
}
}
Another:
{
“eligibility”: {
“minimumDataQuality”: “verified”
}
}
This can prevent inappropriate execution.
Use-Case Preconditions
A workflow may require certain conditions before it begins.
Example:
{
“preconditions”: [
“canonical entity identified”,
“authoritative knowledge available”,
“user intent resolved”
]
}
If a precondition fails:
Do not continue automatically.
Instead:
- resolve the missing entity
- retrieve more knowledge
- ask for clarification
- escalate
AI Automation Levels
Use cases should clearly define automation boundaries.
Informational
AI only provides information.
Example:
Explain GEO.
Assistive
AI helps a person make a decision.
Example:
Compare SEO and GEO strategies.
Preparatory
AI prepares an action.
Example:
Draft an outreach email.
Human-Confirmed
AI can execute after approval.
Example:
Send the prepared email.
Autonomous
AI can execute without immediate human confirmation within predefined boundaries.
Higher automation requires stronger governance.
Risk Classification
Use cases should also have risk classifications.
Low Risk
Examples:
- summarising public content
- brainstorming
- informational answers
Medium Risk
Examples:
- business recommendations
- customer-support routing
High Risk
Examples:
- financial recommendations
- account changes
- sensitive personal decisions
Critical Risk
Examples may include actions with significant safety, legal or irreversible consequences.
The use-case file can specify required controls for each level.
User Persona Mapping
A useful use-case object can define target personas.
Example:
{
“personas”: [
{
“name”: “SEO Manager”,
“needs”: [
“AI visibility monitoring”,
“content gap identification”
]
}
]
}
Persona mapping can affect:
- terminology
- explanation depth
- interface
- outputs
- recommended actions
Intent Mapping
The same persona can have multiple intents.
Example:
SEO Manager
Intent 1:
Measure brand visibility
Intent 2:
Identify citation gaps
Intent 3:
Find content opportunities
Each intent may map to a different use case.
Inputs and Outputs
Every use case should clearly distinguish inputs and outputs.
Example:
Input:
Target queries
Brand
Competitors
↓
Use Case:
AI Visibility Audit
↓
Output:
Mention rate
Citation rate
Competitor comparison
Entity accuracy
This makes integrations easier.
Data Requirements
Use cases may depend on different data.
Examples:
- public webpages
- CRM
- product database
- search-console data
- AI responses
- internal documents
- support tickets
- analytics
A use-case definition should identify its data dependencies.
Tool Requirements
Agentic use cases may require specific tools.
Example:
{
“tools”: [
“web_search”,
“knowledge_base”,
“analytics_api”
]
}
Tool selection can then be governed separately.
Output Schema
Structured output can improve interoperability.
Example:
{
“outputSchema”: {
“query”: “string”,
“brandMention”: “boolean”,
“citationCount”: “integer”,
“entityAccuracy”: “string”,
“recommendations”: “array”
}
}
This is especially useful when outputs feed into:
- dashboards
- APIs
- reports
- workflows
- agents
Success Criteria
Every use case should answer:
What does success mean?
Example:
For an AI Support Assistant:
Correct answers
Fewer escalations
Lower response time
High source accuracy
For AI Visibility Monitoring:
Reliable prompt coverage
Correct entity detection
Accurate citation tracking
Actionable recommendations
Leading and Lagging Metrics
It can be useful to separate metric types.
Leading Metrics
Indicate whether the AI workflow is functioning.
Examples:
- retrieval precision
- citation support rate
- answer accuracy
Lagging Metrics
Measure eventual business impact.
Examples:
- conversion
- support cost
- revenue
- retention
An AI system may perform technically well but produce little business value.
Both types should therefore be monitored where appropriate.
Use-Case Prioritisation
Organisations may have dozens of AI ideas.
They need a method for deciding which to build first.
Useful prioritisation dimensions include:
Business Value
Implementation Feasibility
Data Availability
Risk
Expected Adoption
Measurement Ability
A use-case catalogue can therefore include:
{
“priority”: “high”
}
or a structured evaluation.
AI Use-Case Portfolio
Large enterprises may maintain a portfolio.
Example:
AI Use Cases
├── Marketing
│ ├── AI Visibility
│ ├── Content Gaps
│ └── Competitor Analysis
│
├── Sales
│ ├── Lead Qualification
│ └── Account Research
│
├── Support
│ ├── Q&A
│ └── Ticket Routing
│
└── Enterprise
├── Knowledge Assistant
└── Policy Retrieval
The JSON resource can become a machine-readable catalogue of this portfolio.
Use-Case Dependencies
Some use cases depend on others.
For example:
AI Recommendation
may require:
Entity Resolution
+
Knowledge Retrieval
+
Ranking
A dependency object can define:
{
“dependencies”: [
“capability:entity-resolution”,
“capability:semantic-retrieval”
]
}
Use-Case Status
Each use case can have a lifecycle.
Possible statuses:
proposed
pilot
active
limited
deprecated
retired
Example:
{
“status”: “pilot”
}
Use-Case Versioning
AI applications evolve.
For example:
{
“version”: “2.1”
}
Version history can capture:
- changed workflow
- new data
- new safeguards
- new metrics
- modified automation level
Common Mistakes to Avoid
Mistake 1: Listing Technologies Instead of Use Cases
Bad:
LLM
RAG
Vector Database
Agent
These are technologies.
Better:
Customer Support Q&A
Product Recommendation
AI Visibility Monitoring
Mistake 2: No Business Problem
Do not create a use case without explaining what problem it solves.
Mistake 3: No Defined User
AI applications need a target user or system.
Mistake 4: No Success Metric
If success cannot be measured, improvement becomes difficult.
Mistake 5: Over-Automating
Not every use case should permit autonomous action.
Mistake 6: Ignoring Data Requirements
An attractive AI use case may be impossible without reliable data.
Mistake 7: No Risk Classification
Different applications need different controls.
Mistake 8: No Human Escalation
Important workflows should specify when people need to intervene.
Mistake 9: Confusing Capability With Outcome
“Use GPT” is not an outcome.
Mistake 10: Creating Generic AI Use Cases
A use case such as:
Improve productivity with AI
is too broad.
Define the actual workflow.
Mistake 11: No Feedback Loop
Use cases should be monitored after deployment.
Mistake 12: Ignoring Context
The same AI application may need different behaviour for different markets, users or intents.
Mistake 13: No Governance
Use cases can expand in scope unless boundaries are documented.
Mistake 14: Assuming External AI Systems Will Use the File
Publishing a custom use-case JSON file does not cause ChatGPT, Google, Gemini or another public AI platform to execute those workflows.
Does ai-use-cases.json Improve Google Rankings?
There is no established basis for treating ai-use-cases.json as a direct Google ranking factor.
The file should not be positioned as:
Publish ai-use-cases.json and improve your Google rankings.
Its value lies in:
- AI architecture
- application design
- machine-readable AI documentation
- workflow mapping
- enterprise governance
- RAG orchestration
- GEO planning
Indirectly, use-case-driven AI workflows may help organisations produce better content, improve knowledge quality or identify AI-search gaps.
But those are downstream outcomes.
The JSON file itself is not a confirmed ranking signal.
Does ChatGPT Automatically Read ai-use-cases.json?
Website owners should not assume that ChatGPT automatically discovers or executes instructions from a custom ai-use-cases.json file.
The same applies to:
- Gemini
- Claude
- Perplexity
- Copilot
- Grok
- other public AI systems
The file becomes directly useful when explicitly connected to:
- enterprise AI assistants
- RAG systems
- AI agents
- workflow orchestration
- MCP systems
- internal tools
- AI governance platforms
Implementation Process
Step 1: Identify Business Problems
Start with actual problems.
Ask:
- Where are people losing time?
- Which decisions are repetitive?
- Where is information difficult to retrieve?
- Which AI visibility questions are currently unanswered?
Step 2: Identify Users
Determine who experiences the problem.
Step 3: Define the Goal
Specify the desired outcome.
Step 4: Identify Inputs
Determine what data is required.
Step 5: Identify Required Knowledge
Map relevant pages, databases, entities and structured resources.
Step 6: Select AI Capabilities
Choose only the capabilities needed.
Step 7: Define Workflow
Map major stages.
Step 8: Define Outputs
Specify what the system should produce.
Step 9: Define Automation Boundaries
Determine what AI can do independently.
Step 10: Define Risk
Assess potential consequences.
Step 11: Define Escalation
Determine when human review is required.
Step 12: Define Success Metrics
Measure both technical quality and business outcomes.
Step 13: Connect Feedback
Define how the use case will improve.
Step 14: Test the Workflow
Use representative scenarios.
Step 15: Version and Maintain
Update use-case definitions when workflows or data change.
Validation Checklist
Before deploying ai-use-cases.json, verify:
- JSON syntax is valid.
- Metadata exists.
- File version is present.
- Use-case IDs are unique.
- Every use case has a clear name.
- A problem statement is defined.
- The target user is identified.
- The objective is explicit.
- Inputs are listed.
- Context requirements are known.
- Required data is available.
- Required AI capabilities are defined.
- Related resources are correctly referenced.
- Workflow stages are understandable.
- Expected outputs are defined.
- Automation level is explicit.
- Risk level is assigned.
- Constraints are documented.
- Human-review requirements exist where necessary.
- Success metrics are measurable.
- Feedback requirements are included.
- Status is defined.
- Deprecated use cases are removed or marked.
- Sensitive internal use cases are protected.
- Use cases are not confused with technologies.
- The file is not presented as an external AI ranking mechanism.
Example Connection With ai-ranking-model.json
Use Case:
AI Citation Selection
↓
Candidates:
Multiple supporting sources
↓
AI Ranking Model:
Rank by claim support, authority and freshness
↓
Output:
Best citation candidates
Example Connection With ai-answer-primitives.json
Use Case:
Direct Definition Answering
↓
Intent:
Definition
↓
Answer Primitives:
Retrieve definition primitive
↓
Output:
Concise answer
Example Connection With ai-decision-layer.json
Use Case:
Service Recommendation
↓
User Goal
↓
Candidate Services
↓
Ranking
↓
Decision Layer
↓
Recommended Service
Example Connection With ai-feedback-loop.json
Use Case:
AI Support Q&A
↓
Answer
↓
User Feedback
↓
Human Evaluation
↓
Feedback Loop
↓
Improve Knowledge / Retrieval
Example Connection With context-engine.json
Use Case:
Product Recommendation
↓
Context Engine:
Market
Budget
User Type
Intent
↓
Use-Case Workflow
↓
Context-Aware Recommendation
Example ai.txt Reference
# AI Application Resources
AI Use Cases:
AI Ranking Model:
AI Decision Layer:
This documents available machine-readable resources.
It does not guarantee external crawler adoption.
Example llms.txt Reference
## AI Use Cases
Machine-readable AI application scenarios, capability mappings, workflows and expected outcomes:
Strategic Value of an AI Use-Case Layer
AI infrastructure can become technically impressive but operationally disconnected.
An organisation might possess:
Knowledge Graph
Vector Database
LLM
Agent Framework
Ranking Model
but still struggle to answer:
What should we actually use this for?
ai-use-cases.json provides that bridge.
It connects:
Technology
with:
Business Value
The architecture becomes:
Business Problem
↓
Use Case
↓
Required AI Capability
↓
Required Knowledge
↓
Workflow
↓
Output
↓
Business Outcome
From AI Features to AI Applications
A feature might be:
Summarisation
An application is:
Automatically summarise overnight industry research for the strategy team.
A capability might be:
Entity Recognition
An application is:
Identify whether AI-generated answers correctly recognise the brand, its founder, products and services.
Use-case architecture encourages organisations to think in terms of outcomes rather than novelty.
From AI-Readable Infrastructure to AI-Usable Infrastructure
Machine-readable files tell systems what information exists.
Use-case files explain where that information can produce value.
This progression can be summarised as:
AI-Readable
↓
AI-Retrievable
↓
AI-Rankable
↓
AI-Answerable
↓
AI-Decidable
↓
AI-Actionable
↓
AI-Measurable
↓
AI-Usable
ai-use-cases.json helps define the final business application layer.
Use Cases as the Entry Point to AI Architecture
The earlier AI stack can also be viewed in reverse.
Instead of asking:
What can this JSON file do?
start with:
What does the user need?
Then determine:
Use Case
↓
Context Requirements
↓
Knowledge Requirements
↓
Ranking Requirements
↓
Answer Requirements
↓
Decision Requirements
↓
Action Requirements
↓
Feedback Requirements
This produces more purposeful AI infrastructure.
Strategic Value for GEO, AEO and LLM SEO
For organisations working on AI search visibility, a Use Case layer can transform abstract GEO concepts into concrete workflows.
Examples:
AI Citation Gap Analysis
Determine where competitors receive citations but the target brand does not.
Entity Accuracy Monitoring
Identify whether generative systems correctly understand brand identity and relationships.
Answer Coverage Analysis
Determine whether authoritative content exists for important conversational queries.
AI Competitor Visibility
Compare how often competitors appear across selected generative-query categories.
Knowledge Gap Detection
Identify questions where the organisation lacks a sufficiently authoritative answer.
Content Refresh Prioritisation
Determine which outdated resources are most likely to affect AI responses.
These are clear use cases.
Each can then connect to:
- entities
- ranking models
- answer primitives
- decision rules
- feedback systems
Final Summary
ai-use-cases.json is a proposed machine-readable framework for describing where and how AI capabilities should be applied to real-world tasks.
It can define:
- business problems
- users
- goals
- triggers
- inputs
- contextual requirements
- knowledge requirements
- AI capabilities
- workflows
- ranking requirements
- answer requirements
- decision requirements
- actions
- automation levels
- risk
- constraints
- human review
- outputs
- metrics
- feedback
Its role in the wider AI stack can be summarised as:
Entity Registry
Defines what exists.
Knowledge Graph
Defines how information is connected.
Brand Memory
Defines what should be remembered.
Context Engine
Defines what matters now.
AI Use Cases
Define where AI should be applied and why.
AI Ranking Model
Defines which candidates should receive priority.
AI Answer Primitives
Define what reusable knowledge can be said.
Reasoning Map
Defines how evidence and concepts connect.
AI Decision Layer
Defines what should happen.
AI Feedback Loop
Determines whether the result worked and what should improve.
The use-case layer therefore connects:
AI Infrastructure
to:
Real User and Business Outcomes
Its value is not in listing impressive AI terminology.
Its value is in making AI implementation intentional.
A strong AI use case should make clear:
- who needs the AI
- what problem exists
- why AI is appropriate
- what information is required
- what the system should produce
- what it is allowed to do
- how success will be measured
- how failure will be corrected
As organisations build increasingly sophisticated AI systems, the most important question is not simply:
What can AI do?
It is:
Where can AI deliver reliable, measurable and governed value?
That is the role ai-use-cases.json is designed to support.
