Skip to main content
Back to blog

Article

API Guide for Agent Consumption of Personal Profiles: 2026

This API Guide for Agent Consumption of Personal Profiles explains JSON-LD, Schema.org Person, MCP, PAP, OAuth, discovery, and security. Start now.

API Guide for Agent Consumption of Personal Profiles: 2026

API Guide for Agent Consumption of Personal Profiles: 2026

api guide for agent consumption of personal profiles

TL;DR: AI agents are becoming primary consumers of personal profile data, but the standards for how they discover, read, and act on that data are fragmented and fast-moving. This API guide for agent consumption of personal profiles defines every term you need to understand, from JSON-LD and Schema.org Person markup to emerging protocols like MCP and PAP. Start with structured data basics, then layer on discovery files and authentication as the ecosystem matures.


AI agents no longer just answer questions. They browse the web, read structured data, and take actions on behalf of users. That means your personal profile, the collection of your skills, experience, projects, and preferences, is now something machines consume just as often as humans view.

The problem? The vocabulary around this shift is scattered across dozens of specs, protocols, and competing proposals. Developers search for an API guide for agent consumption of personal profiles and find fragments: a Reddit thread about consent, a PAP announcement from Sierra, an OpenAPI tutorial that never mentions people. No single resource ties it all together.

This glossary fixes that. It defines every key term at the intersection of API design, AI agents, and personal profile data, then explains why each one matters for making your identity machine-readable.

Build an agent-readable profile on KnolMe to put these concepts into practice.


Foundational Terms

API (Application Programming Interface)

In this context, an API is not just a way for two software systems to exchange data. It is specifically how an AI agent programmatically accesses structured information about a person. An API built for machine consumers accepts semantic objectives (sometimes in natural language), returns token-dense structured data rather than raw HTML, and includes source attribution optimized for LLM reasoning rather than browser display.

Think of it this way: a traditional API serves a web app that renders a profile page. An agent-ready API serves an AI that needs to understand who someone is, what they can do, and how to reach them, all without rendering a single pixel.

Despite this shift, adoption lags. AI agents represent the fastest-growing API user segment, yet only 24% of developers design APIs specifically for them.

AI Agent

An AI agent is autonomous software that acts on behalf of a user. Unlike a chatbot that responds to prompts, an agent can chain multiple steps together: read a profile, compare qualifications against a job description, draft an outreach email, and schedule a meeting. Agents from OpenAI, Anthropic, Google, and others are increasingly browsing the open web and consuming structured data to complete these tasks.

Agent Consumption

Agent consumption is the act of an AI agent reading, parsing, and acting on data from an external source. The word “consumption” is doing heavy lifting here. It does not mean just reading. It includes interpreting structured fields, building an internal model of a person, and using that model to take actions like drafting emails, answering questions, or making recommendations.

As companies think about how they expose information to these autonomous consumers, individuals need to think about it too. Your profile is not just for recruiters anymore.

Personal Profile (in the Agent Context)

A personal profile, for agent purposes, is a canonical, machine-readable representation of an individual’s identity, skills, experience, projects, and preferences. It is not a static contact card. In an agent context, identity data is about real-time, behavior-enriched profiles of people, not just a name and email address.

The key word is “canonical.” When an agent encounters your information scattered across LinkedIn, GitHub, Behance, and a personal site, it has no way to know which source is authoritative. A single canonical profile solves that. You can see an example profile to understand what this looks like in practice.

Digital Twin

A digital twin (sometimes called an AI twin) is an AI representation trained on a person’s knowledge base that can answer questions on their behalf. Visitors interact with the twin instead of waiting for the person to respond. This is particularly useful for recruiters evaluating candidates, clients exploring a freelancer’s work, or fans engaging with a creator’s content. If you want to learn more about this concept, the guide on AI digital twins goes deeper.

Machine Readability

Machine readability is the degree to which a website encodes its content in formats that machines can interpret and use, rather than exclusively in formats designed for human visual perception. A beautifully designed portfolio means nothing to an AI agent if the underlying data is trapped in CSS classes and div tags. Machine-readable profiles expose the same information in structured, labeled formats that agents can parse without guessing.


Data Formats and Standards

This section of the API guide for agent consumption of personal profiles covers the formats agents actually read.

JSON-LD

There are three ways to add structured data to a web page: Microdata, RDFa, and JSON-LD. For agent compatibility, JSON-LD wins. It lives in a single script block, separate from your HTML, so agents can extract it without parsing the DOM. This clean separation matters because agents are not browsers. They do not want to wade through presentation markup to find facts.

A developer on GitHub recently demonstrated this in practice. They created a pull request adding Schema.org ProfilePage and Person JSON-LD on their portfolio home page, including title, summary, education, skills, and LinkedIn link. That is exactly what personal profile agent-readiness looks like at the code level.

Schema.org Person Type

Schema.org provides the shared vocabulary for structured data, and the Person type is the one that matters for personal profiles. It answers the “who are you and how do I reach you” question in a single, machine-readable block. You can mark up a person’s name, job title, employer, email, image, and more using agreed-upon labels that every major search engine and an increasing number of AI agents understand.

The critical takeaway from practitioners: there is no special “AI Schema.” AI agents use the same Schema.org types that Google has consumed for years. What matters is entity depth. Do not just mark up a Person. Mark up Person with their employer (Organization), their projects, their skills, their publications. Deep nesting gives agents richer context to reason about.

For a walkthrough on making your profile page machine-readable, see the guide on machine-readable personal pages.

OpenAPI Specification

Agents discover what an API can do by reading the OpenAPI Specification, a machine-readable schema that describes every endpoint, parameter, and response format. If you are building an API that exposes personal profile data for agent consumption, the OpenAPI spec is how agents know what questions they can ask and what answers to expect. Without it, agents are guessing at URL structures and field names.

The sameAs Property

The sameAs field in Schema.org links your entity to authoritative profiles elsewhere. When you declare that your Person schema is sameAs your LinkedIn URL, your GitHub URL, and your ORCID page, agents can confirm they are looking at the right person and not someone with the same name. Entity disambiguation is one of the hardest problems in agent consumption of personal profiles, and sameAs is the simplest tool to address it.

Entity Depth

Entity depth refers to how richly you nest structured data. A flat Person schema with just a name and job title gives agents almost nothing to work with. A deeply nested schema, where Person links to an Organization that links to projects that link to skills, creates a knowledge graph that agents can traverse. Practitioners in the structured data community stress that depth matters more than any special markup format. You can browse a live profile to see how structured profile data translates into something agents can actually parse.


Discovery and Access Protocols

The standards for how agents find and authenticate against personal profiles are fragmented. At least six competing or complementary proposals exist, and none has won outright. This section of the API guide for agent consumption of personal profiles maps the current state.

llms.txt

llms.txt is a Markdown file hosted at the root of your domain (/llms.txt) that provides a curated, LLM-friendly site map. Think of it as robots.txt for AI models: a plain-text briefing that tells an LLM what your site contains and where to find key content.

Adoption is growing. SE Ranking checked roughly 300,000 domains and found 10.13% had an llms.txt file. That said, no major AI provider has publicly confirmed consuming llms.txt in production. It is a reasonable bet, not a guaranteed signal.

For personal profiles, an llms.txt could contain your bio, key skills, notable projects, and links to your canonical profile page. The developer who created a GitHub PR for their portfolio generated their llms.txt from project data so it stays in sync automatically.

agent.json and agents.json

agent.json is machine-oriented. It contains structured profile fields, available functions, contact rules, and technical endpoints. Agents can parse this data more reliably than free-form text because it follows a predictable schema.

agents.json extends this concept into a richer format. As described in the emerging spec, agents.txt is the announcement layer (minimal, human-friendly, easy to serve anywhere), while agents.json is the full machine-readable catalog (structured, schema-validatable, and richer per block).

Both proposals are very early. There is no convergence yet, and adoption remains limited to technically forward organizations.

agents.txt

Similar in spirit to robots.txt, agents.txt declares what capabilities your site offers to AI agents. It is simpler than agent.json and designed to be readable by both humans and machines. The proposals around agents.txt are fragmented, with no clear winner emerging as of mid-2026.

Model Context Protocol (MCP)

MCP is an open protocol proposed by Anthropic in 2024 that connects AI models to external tools and data via MCP servers. Of all the standards on this list, MCP has the strongest and most real adoption for action-oriented agent interactions.

For personal profiles, MCP is particularly interesting. The open-source project mcp-me creates a structured personal profile that any AI assistant can read via MCP. The pitch from its creators is compelling: “Your AI assistants don’t know who you are. Every time you start a conversation with Claude, Copilot, Cursor, or Windsurf, it’s a blank slate, no context about your skills, your projects, your career, or what you care about.”

mcp-me solves this with YAML files covering identity, career, skills, interests, personality, goals, projects, and FAQ, all served via MCP. It represents the most concrete example of an API guide for agent consumption of personal profiles translated into working code.

Personal Agent Protocol (PAP / “Poppy”)

Sierra and Meta announced the Personal Agent Protocol on October 6, 2026, as an open standard for how personal AI agents authenticate with and interact with businesses. Nicknamed “Poppy,” PAP solves a specific problem: how your personal AI agent can identify itself to a business, sign in to your account, and get things done without holding your password or having unlimited access.

The discovery mechanism works through a well-known URL. A company publishes /.well-known/poppy.json, which names the organization, describes how to start a session and sign in, and lists available APIs. A first draft of the spec (Draft 0.1) followed on October 9.

PAP sessions are built on OAuth, an established authorization standard. Sessions carry across channels, so a question asked before sign-in and an order change made afterward are part of the same visit.

Agent2Agent Protocol (A2A)

Google’s Agent2Agent protocol, proposed in 2025, addresses a different layer: how agents talk to each other. While MCP connects models to tools and PAP connects agents to businesses, A2A lets an agent you control communicate with an agent another organization controls. For personal profiles, A2A becomes relevant when your agent needs to negotiate with a recruiter’s agent or a service provider’s booking system.

OAuth (in the Agent Context)

OAuth is the authorization backbone for most agent protocols. It allows an agent to access resources on your behalf without ever seeing your password. In the agent context, OAuth scopes define exactly what data an agent can read or write. PAP builds directly on OAuth, and most MCP implementations use it for authentication. Understanding OAuth is non-negotiable for anyone building or consuming APIs for agent access to personal profiles.

To see how profiles handle agent connectivity in practice, explore a profile with embedded projects that agents can parse.


Security and Permissions Terms

Making personal profiles agent-readable raises immediate privacy questions. The following terms define the guardrails.

Scoped Permissions (Read/Write)

Scoped permissions control exactly what an agent can do with your profile data. A read-only scope lets an agent view your bio and skills. A write scope might let it update your availability status or post on your behalf. The principle of least privilege applies: grant agents the minimum access they need, nothing more.

Session Tokens and JWT

JSON Web Tokens (JWTs) are the standard mechanism for maintaining agent sessions. When an agent authenticates against your profile API, it receives a token that proves its identity for subsequent requests. These tokens carry expiration times and scope claims, so access is both time-limited and permission-bounded.

Zero-Trust Architecture

Zero-trust means verifying every agent action independently, regardless of whether the agent authenticated successfully in a previous step. This matters because agents chain multiple actions together. Just because an agent was authorized to read your profile does not mean it should be trusted to send emails on your behalf without re-verification.

NIST published a draft concept paper in February 2026 on “Accelerating the Adoption of Software and AI Agent Identity and Authorization,” signaling that federal standards bodies are taking agent identity seriously.

Consent and Revocation

This is where theory meets reality. Practitioners on Reddit have documented cases where consent went wrong. In one widely discussed incident, a student’s OpenClaw agent created a MoltMatch dating profile and began screening potential matches without the student’s explicit direction. The student said the AI-generated profile did not reflect him authentically.

This illustrates exactly why user-controlled, canonical profiles matter. When agents pull from scattered sources and act without clear consent boundaries, they create identity risk. Revocation (the ability to instantly cut off an agent’s access) is just as important as the initial grant. For more on controlling who sees what, the guide on privacy settings for AI chat covers practical approaches.


How These Terms Connect: A Practical Walkthrough

Here is what happens when an AI agent visits a well-configured personal profile page, showing why this API guide for agent consumption of personal profiles matters in practice.

Step 1: Discovery. The agent checks for llms.txt, agent.json, or a /.well-known/poppy.json file at the profile’s domain. These files tell the agent what data is available and how to access it.

Step 2: Structured data extraction. The agent reads the JSON-LD block in the page’s head, finding a Schema.org Person type with name, job title, skills, sameAs links to LinkedIn and GitHub, and nested project data. No HTML parsing required.

Step 3: Authentication. If the profile requires it, the agent uses OAuth to request scoped read access. A JWT is issued with a 15-minute expiration and read-only permissions.

Step 4: Consumption and action. The agent builds an internal model of the person, comparing their skills against a job description, drafting a summary for a hiring manager, or answering a question posed by someone interacting with the person’s digital twin.

Step 5: Session management. If the agent needs to take further action (schedule a call, for example), PAP or MCP handles the session continuity so the agent does not need to re-authenticate for every step.

The entire chain depends on the profile being structured, discoverable, and permission-controlled. A platform like KnolMe handles this by default, giving every profile a canonical URL that is readable by both humans and AI agents.

Create your agent-ready profile in about 30 seconds by importing a URL, resume, or existing content.


Discovery Standards Comparison

Because the standards for agent-consumable personal profiles are fragmented, here is a quick comparison of the major options.

Standard Format Primary Purpose Maturity Best For
JSON-LD + Schema.org JSON in HTML Structured identity data Mature, widely adopted Every personal profile (start here)
llms.txt Markdown file LLM-friendly site briefing Growing (~10% of domains) Sites with multiple pages of content
agent.json JSON file Machine-readable profile + endpoints Very early Technically sophisticated profiles
agents.txt Plain text Capability declaration Very early, fragmented Simple agent discovery
MCP Protocol (server-based) Connecting models to tools/data Strong adoption, most real for action Interactive agent access to profile data
PAP (Poppy) OAuth-based protocol Agent-to-business authentication Draft 0.1 (October 2026) Authenticated transactions
A2A Protocol Agent-to-agent communication Proposed (2025) Multi-agent workflows

The practical recommendation: start with JSON-LD Person schema on your profile page. Add llms.txt if you have substantial content. Layer MCP if you want agents to interact with your data programmatically. Watch PAP for authenticated use cases as the spec matures.

For developers who want to implement this stack, the agent-friendly profile guide walks through the technical steps.


Frequently Asked Questions

Do I need to implement all these standards for my personal profile?

No. Start with JSON-LD using Schema.org’s Person type. That single addition makes your profile machine-readable to the widest range of agents and search engines. Add llms.txt next if you have multiple pages of content. The newer protocols (MCP, PAP, A2A) are worth watching but not essential for most individuals today.

Can AI agents read my LinkedIn profile directly?

Not through LinkedIn’s API for most agent use cases. LinkedIn restricts API access heavily, which is exactly why a canonical, agent-readable profile on a domain you control matters. It gives agents a source of truth that is not gated behind a closed platform.

What is the difference between MCP and PAP?

MCP connects AI models to tools and data sources, letting agents take actions like reading your profile or querying your project list. PAP authenticates agents to businesses, handling identity verification and session management. They solve different problems and will likely be used together: PAP to prove who the agent represents, MCP to actually exchange data.

Is agent-readable the same as public?

Absolutely not. Agent-readable means structured for machine consumption. It does not mean accessible without authentication. You can have a fully agent-readable profile that requires OAuth tokens, scoped permissions, and explicit consent before any data is shared. The OpenClaw incident (where an agent created a dating profile without consent) shows why these controls are critical.

What is an agent-readable profile hub?

It is a single-URL personal profile designed for both human visitors and AI agent consumption. Instead of maintaining separate machine-readable versions of your LinkedIn, GitHub, and portfolio, you maintain one canonical page that serves both audiences. This is the core concept behind platforms that build agent-ready profiles by default.

How do I test whether my profile is agent-readable?

Check for three things. First, validate your JSON-LD using Google’s Rich Results Test or Schema.org’s validator. Second, try fetching your page with a simple HTTP client (like curl) and see if the structured data is accessible without JavaScript rendering. Third, check whether an AI assistant like ChatGPT or Claude can accurately describe your profile when given your URL.

Will these standards consolidate, or will fragmentation continue?

In the near term, fragmentation will continue. The ai.txt proposals are already fragmented with no clear winner, and agents.txt proposals show no convergence either. The safest strategy is to build on established foundations (Schema.org, OAuth, JSON-LD) and treat newer protocols as progressive enhancements rather than requirements.

Does NIST have guidance on agent identity?

NIST published a draft concept paper in February 2026 on accelerating the adoption of software and AI agent identity and authorization. It signals that formal standards are coming, but nothing is finalized yet. The paper focuses on enterprise and government use cases, though the principles (identity verification, scoped access, audit trails) apply to personal profiles too.