How to Make My Personal Page Machine-Readable for Tools 2026
TL;DR
AI tools, search engines, and agents are the new visitors to your personal page, but most personal pages are invisible to them. Making your page machine-readable means adding structured data (JSON-LD with Person and ProfilePage schema), configuring robots.txt for AI crawlers, using semantic HTML, and optionally creating an llms.txt file. This guide defines every concept you need and gives you a priority checklist to follow.
The people visiting your personal page are increasingly not people at all. They’re GPTBot crawling on behalf of ChatGPT. They’re PerplexityBot pulling answers for a recruiter who asked “who’s a good frontend developer in Chicago?” They’re Claude-SearchBot trying to figure out whether you’re the right person to cite in a response.
If your personal page is a wall of unstyled divs with no structured data, these tools see nothing useful. They skip you. Someone else gets the citation, the recommendation, the opportunity.
This glossary covers every concept involved in making your personal page machine-readable for tools. Each term gets a plain definition, an explanation of why it matters for your specific use case (not a business site, not an e-commerce store, your personal page), and practical guidance on what to do about it. To see what a machine-readable profile looks like in practice, that’s a useful reference point as you read through.
The concepts are organized from foundational to emerging, so you can stop wherever your comfort level ends and still walk away with something actionable.
Foundational Concepts
Machine-Readable
Content is machine-readable when software can parse, interpret, and act on it without human help. This goes beyond “my page loads in a browser.” A page can render beautifully for a human and be completely opaque to an AI agent.
For personal pages, this matters more than most people realize. LLMs and search assistants are increasingly used to research people and ideas. If you don’t provide a clear, structured source about yourself, AI will construct a profile from whatever scattered data it can find, often inaccurately. A developer on DEV.to put it well: AI needs canonical sources, and if you don’t provide one, the network will infer one from whatever fragments exist across the web.
Your personal page should be that canonical source.
Structured Data and Schema Markup
Structured data is code embedded in your HTML that tells machines what your content means, not just what it says. Schema markup is the vocabulary (defined at schema.org) used to write that code.
Think of it this way: your page might say “Jane Smith, Software Engineer at Acme Corp” in plain text. A human reads that and understands the relationships. A machine sees a string of characters. Structured data makes those relationships explicit: this is a Person, her jobTitle is “Software Engineer,” and she worksFor an Organization called “Acme Corp.”
Schema markup provides the vocabulary. The format you write it in is a separate choice.
JSON-LD
JSON-LD (JavaScript Object Notation for Linked Data) is the format Google recommends for embedding structured data. It lives inside a <script type="application/ld+json"> tag in your page’s <head>. Browsers ignore it. Machines read it.
Practitioners on Reddit’s r/TechSEO consistently favor JSON-LD over alternatives like Microdata because it separates data from HTML, making it easier for AI parsers that may strip or ignore rendered markup. This separation also means you can add or modify structured data without touching your page layout.
Here’s a minimal JSON-LD snippet for a personal page:
{
"@context": "https://schema.org",
"@type": "ProfilePage",
"dateCreated": "2025-01-15",
"dateModified": "2026-06-01",
"mainEntity": {
"@type": "Person",
"name": "Jane Smith",
"jobTitle": "Software Engineer",
"url": "https://janesmith.dev",
"sameAs": [
"https://linkedin.com/in/janesmith",
"https://github.com/janesmith"
]
}
}
That’s it. This alone makes your page dramatically more interpretable by every major AI tool and search engine.
If you’d rather not write this code yourself, platforms like KnolMe auto-generate profiles with structured data built in, so the machine-readable layer is handled from the start.
The Schema Types That Matter for Personal Pages
Person Schema
The Schema.org Person type describes an individual. It’s the most important schema type for your personal page because it connects your name to your credentials, work, and online presence in a way machines can parse.
Key properties to include:
- name: Your full name
- jobTitle: Current role
- url: Your personal page URL
- image: A profile photo URL
- sameAs: Links to your other profiles (more on this below)
- worksFor: Your employer (as an Organization type)
- alumniOf: Educational institutions
- knowsAbout: Skills and topics you’re expert in
- description: A brief bio
When AI tools cite content, they often cite people by name. Person schema makes those connections explicit. As AI systems increasingly prioritize content from verified experts over anonymous sources, this markup becomes your proof of identity.
A developer who implemented Person schema on their portfolio reported on DEV.to that when a crawler hits the page, the structured data explicitly communicates: “This is a Person named [X], his job is Applied AI Engineer, he’s the same as this GitHub profile and Twitter account.” That’s how AI builds its knowledge graph. That’s how you become citable.
ProfilePage Schema
ProfilePage is a wrapper that tells machines “this entire page is dedicated to a specific person.” It’s the outer layer; Person is the inner layer (the mainEntity).
According to Google’s documentation, at minimum you need mainEntity with name or alternateName. But you should also include dateCreated and dateModified so machines know how current the information is.
The structure works like this: ProfilePage describes the page itself (when it was made, when it was last updated). The Person inside it describes you. Google explicitly states that ProfilePage markup is designed for sites where creators share first-hand perspectives, and adding it helps Google Search understand the creators behind the content.
You can see this pattern implemented on this example profile, where ProfilePage wraps a Person entity with linked social accounts and project details.
The sameAs Property
The sameAs property links your personal page to your other authoritative profiles across the web: LinkedIn, GitHub, X/Twitter, Behance, Google Scholar, whatever is relevant to your field.
This is how you tell machines “all of these profiles are the same person.” Search engines use sameAs to build Knowledge Graph entries. AI tools use it to verify identity and consolidate information.
The format is simple, just an array of URLs:
"sameAs": [
"https://linkedin.com/in/yourname",
"https://github.com/yourname",
"https://twitter.com/yourname"
]
If you’re working to combine LinkedIn, GitHub, and portfolio into one coherent presence, sameAs is the technical mechanism that ties them together for machines.
Making Your Page Discoverable by AI
Structured data tells machines what your page means. But none of that helps if machines can’t reach your page in the first place.
Robots.txt and AI Crawlers
Robots.txt is a 30-year-old text file that tells crawlers which parts of your site they may fetch. In 2026, it’s doing a job it was never designed for: controlling access for dozens of AI crawlers operated by OpenAI, Anthropic, Google, Perplexity, Apple, Amazon, and Meta.
The critical distinction most people miss: training and search are now separate crawlers. GPTBot and Google-Extended train models. OAI-SearchBot and Claude-SearchBot retrieve content for real-time answers. You can block training while staying eligible for AI search citations.
If you want AI tools to recommend you when someone asks “who is a good developer in [city],” you need to allow the search and retrieval crawlers. Many personal sites have broad disallow rules (or CMS defaults) that inadvertently shut the door on all AI agents.
The crawlers that matter most in 2026, roughly 12 to 15 in total:
- GPTBot / OAI-SearchBot / ChatGPT-User (OpenAI)
- ClaudeBot / Claude-SearchBot (Anthropic)
- PerplexityBot / Perplexity-User (Perplexity)
- Google-Extended (Google AI training)
- Applebot-Extended (Apple)
- Amazonbot (Amazon)
- Meta-ExternalAgent (Meta)
A minimal robots.txt that allows AI search while blocking training:
User-agent: GPTBot
Disallow: /
User-agent: OAI-SearchBot
Allow: /
User-agent: ClaudeBot
Disallow: /
User-agent: PerplexityBot
Allow: /
Audit yours. This takes five minutes and is the highest-impact quick win for discoverability.
llms.txt
The llms.txt file is a plain-text, Markdown-formatted file hosted at your site’s root directory. Proposed by Jeremy Howard (co-founder of Answer.AI) in September 2024, it provides AI agents with a concise map of your most important content.
Think of it as a README.md for your entire site, but designed for AI consumption.
The structure is simple:
- H1: Your name (the only required element)
- Blockquote: A short summary of who you are. This is the most important line, as it’s what AI models use to understand your identity.
- Links: A curated list of your most important pages, each with a one-line description
Keep it under 500 words. Vercel’s study of 1,023 real agent runs found that 36% of runs that reached an llms.txt file grounded their final answer in its content. That’s significant for such a simple file.
An important caveat: llms.txt is not an official web standard, not a confirmed Google ranking factor, and not a replacement for robots.txt, sitemaps, or schema markup. It’s a useful convention that’s gaining traction, and for a personal page it takes about ten minutes to create.
For deeper guidance on making your profile readable by specific AI tools, the guide on connecting your profile to ChatGPT and Claude covers the practical steps.
How AI Agents Actually Read Your Page
Understanding how agents parse content helps you structure your page correctly. It’s not the same as how Google’s traditional crawler works.
Semantic HTML
Semantic HTML uses elements that convey meaning about their content: <article>, <section>, <nav>, <header>, <main>, <footer>, <button>. These are fundamentally different from generic <div> and <span> tags, which carry no structural signal whatsoever.
A layout built entirely from divs gives an AI agent nothing to work with. It can’t tell your navigation from your bio from your project list. But semantic elements create a clear hierarchy: this is the main content, this is a navigation menu, this is an article about a project.
Google’s web.dev guidance now explicitly advises developers to treat AI agents as a distinct visitor type and recommends practices similar to accessibility practices. The overlap between accessibility and AI readability is almost total, and that’s the key insight.
For your personal page, this means:
- Wrap your bio in
<article>or<section> - Use proper heading hierarchy (H1 for your name, H2 for sections like “Projects” and “Experience”)
- Use
<nav>for navigation links - Use
<main>for primary content - Use descriptive link text, not “click here”
The Accessibility Tree
The accessibility tree is a browser-native API that distills the DOM into roles, names, and states of interactive elements. It’s the page’s semantic summary, originally built for assistive technology like screen readers.
For AI agents, it functions as a high-fidelity map that strips away all the visual noise of CSS, decorative images, and layout wrappers. OpenAI has confirmed that ChatGPT Atlas uses ARIA tags (the same labels and roles that support screen readers) to interpret page structure and interactive elements.
The efficiency gains are striking. A typical page might have 47 nodes of styling classes, layout divs, and visual attributes in the DOM. The accessibility tree reduces that to 5 nodes. That’s 93% more token-efficient than raw DOM parsing, and every major AI agent framework is converging on this approach.
What this means for your personal page: if you write semantic HTML and add proper ARIA labels where needed, AI agents can read your page efficiently and accurately. If you rely on divs and spans with CSS-driven visual structure, agents waste tokens parsing noise and may misinterpret your content.
Content Negotiation and Markdown Alternates
Content negotiation means serving different content formats from the same URL based on what the requester asks for. A browser gets HTML. An AI agent requesting text/markdown gets a clean Markdown version.
For personal pages, the practical version of this is creating .md alternates of your key pages. Every page on your site should ideally have a clean Markdown version available. Combined with llms.txt, this gives AI agents a fast path to your content without parsing complex HTML.
Priority order if you’re just getting started: audit your robots.txt first (five minutes, highest impact), create an llms.txt file next, then set up per-page Markdown files if you have the bandwidth.
Emerging Standards
These concepts are newer, less established, and not required for most personal pages today. But they’re worth knowing about.
Well-Known Files
The /.well-known/ directory is a standardized location on a domain where machines look for discovery metadata. Two AI-relevant files are emerging:
agent-card.json: Part of Google’s Agent2Agent (A2A) protocol. Each agent publishes a card at /.well-known/agent-card.json describing its name, capabilities, and endpoint. This is mostly relevant for AI-to-AI services, not static personal pages.
agents.json: Built on the OpenAPI standard, it lets websites declare AI-compatible interfaces and authentication schemes. Hosted at /.well-known/agents.json.
Vercel’s study found that agents reached a .well-known path in 22.7% of 1,033 runs. That’s enough to be aware of, but not enough to prioritize over schema markup and robots.txt.
Inline LLM Instructions
A newer proposal uses <script type="application/llms+txt"> tags embedded directly in page HTML to give AI-specific context. Browsers skip <script> tags with unknown types, so this has zero impact on visitors. LLMs process them.
It’s a zero-cost way to give every page a machine-readable context block without maintaining separate files. The convention is still emerging, but it’s trivial to implement if you’re comfortable editing HTML.
Agent Cards and Protocol Discovery
As AI agents become more autonomous (booking flights, scheduling meetings, purchasing services), they need to discover what actions a website supports. Agent cards and protocol files serve this discovery function.
For a personal page, these are mostly irrelevant today unless you’re offering an API or service that agents should interact with programmatically. Keep them on your radar but don’t lose sleep over them.
Quick-Start Priority Checklist
This is the order that gives you the most machine-readability for the least effort. Each step builds on the previous one.
-
Add Person + ProfilePage JSON-LD. This is the single most impactful thing you can do. Copy the template from earlier in this guide, fill in your details, and paste it in your page’s
<head>. It takes fifteen minutes and makes your page interpretable by every major AI tool and search engine. -
Audit your robots.txt. Check that you’re not accidentally blocking AI search crawlers. Allow OAI-SearchBot, PerplexityBot, and other retrieval bots. Block training crawlers if you prefer. Five minutes.
-
Use semantic HTML. Replace meaningless
<div>wrappers with<article>,<section>,<main>, and proper heading hierarchy. This helps both AI agents and accessibility. -
Add sameAs links. Connect your personal page to LinkedIn, GitHub, and other profiles in your JSON-LD. This is how machines verify your identity across the web.
-
Create an llms.txt file. Write a short Markdown file with your name, a one-paragraph summary, and links to your most important pages. Host it at your domain root.
-
Validate everything. Use Google’s Rich Results Test to confirm your structured data is correct. Check your robots.txt with Google Search Console.
If you want to learn more about building a profile that AI assistants can learn from, that guide walks through the process from the agent’s perspective.
Or if you’d rather skip the manual work entirely, KnolMe builds agent-readable profiles automatically, with structured data, AI-friendly formatting, and one-click access for ChatGPT, Claude, and other AI tools. The free plan includes one profile with no credit card required.
For more guides on AI-readable profiles and related topics, explore the blog.
Frequently Asked Questions
Do I need all of these concepts to make my personal page machine-readable?
No. Start with JSON-LD (Person + ProfilePage schema) and a clean robots.txt. Those two steps alone cover the majority of what AI tools need to parse your page. Everything else is incremental improvement.
Is llms.txt an official web standard?
Not yet. It was proposed by Jeremy Howard in September 2024 and has gained significant traction, but it’s not an official W3C or IETF standard. It’s a convention, similar to how robots.txt itself started as an informal agreement before becoming widely adopted. Vercel’s study of 1,023 agent runs showed that 36% of runs reaching an llms.txt file grounded their final answer in its content, so it’s clearly useful even without formal standardization.
Will adding structured data make me show up in AI search results?
Structured data dramatically increases your chances, but it’s not a guarantee. Developer Naman Barkiya reported on DEV.to that combining Person schema, an open robots.txt, and verifiable content made his portfolio rank #1 on ChatGPT search. His advice: include specific, quantified achievements, named entities (companies, tools, technologies), and external verification links alongside the technical markup.
What’s the difference between blocking AI training and blocking AI search?
OpenAI and Anthropic now operate separate crawlers for each purpose. GPTBot trains OpenAI’s models. OAI-SearchBot retrieves content for real-time ChatGPT answers. You can block one without blocking the other in your robots.txt. For a personal page, you almost certainly want to allow search crawlers, as that’s how you get recommended and cited.
Does semantic HTML really matter if I already have JSON-LD?
Yes, because AI agents read your page through multiple channels. JSON-LD provides structured metadata. Semantic HTML provides structural context for the actual content. Vercel’s study found that 82.5% of AI agent answers traced to a fetched page, and agents parse that page content through the DOM and accessibility tree, not just the JSON-LD. Both layers matter.
How often should I update my structured data?
Whenever your professional details change: new job title, new employer, new skills, new social profiles. The dateModified field in your ProfilePage schema signals freshness to AI tools. A page last modified in 2023 will be treated as less current than one updated this month.
Can a platform handle all of this for me?
Yes. Platforms like KnolMe auto-generate profiles with structured data, agent-friendly formatting, and one-click AI access built in. The trade-off is less granular control compared to hand-coding everything yourself. For most people who aren’t developers, the automated approach covers the essentials without requiring any technical knowledge. If you want to build an agent-readable profile with more customization, the developer guide walks through the manual process step by step.
What about personal pages on platforms I don’t control, like LinkedIn?
You can’t add JSON-LD or llms.txt to LinkedIn. That’s exactly why having your own personal page matters. Your LinkedIn profile becomes one of several sameAs links pointing back to your canonical page, the one where you control the structured data, the content, and the machine-readable layer. The personal page is the hub; everything else is a spoke.