Schema untuk AI Agent Readiness: Apa yang Bisa dan Tidak Bisa Dilakukan

“Bisa nggak kita bikin schema supaya AI agent tahu cara booking layanan kita?”

Pertanyaan ini terdengar seperti perkembangan natural dari structured data.

Dulu schema membantu menjelaskan:

Ini Product.

Ini Organization.

Ini Event.

Ini Offer.

Ini Action.

Sekarang AI agents mulai:

Membandingkan product.

Mencari availability.

Mengisi form.

Mengakses tools.

Memanggil API.

Booking.

Mengirim data.

Melakukan task atas nama user.

Wajar kalau tim berpikir:

“Tinggal tambah schema, kan?”

Tidak sesederhana itu.

Schema.org bisa membantu mendeskripsikan entities, actions, dan entry points secara semantic.

Tetapi AI-agent readiness yang benar membutuhkan lebih dari deskripsi.

Agent harus tahu:

Apa capability?

Endpoint?

Input?

Output?

Authentication?

Authorization?

Permission?

Error model?

State?

Confirmation?

Security?

Trust?

Schema.org bukan universal agent protocol.

Di 2026, protocol seperti Agent2Agent (A2A) dan Model Context Protocol (MCP) punya fungsi yang lebih dekat ke machine-to-machine interaction.

Jadi strategy yang sehat harus membedakan:

Describing an action.

Exposing an executable tool.

Authorizing an agent.

Schema Bisa Menjelaskan Potential Action

Schema.org punya Action vocabulary.

`potentialAction` dapat menunjukkan action potensial yang bisa dilakukan pada suatu Thing.

Action bisa punya `target`.

Target bisa berupa URL atau EntryPoint.

Secara semantic, ini berguna.

Contoh conceptual:

Restaurant:
potentialAction → ReserveAction.

Movie:
potentialAction → WatchAction.

CreativeWork:
potentialAction → ReadAction/ViewAction.

Product:
BuyAction dalam model yang applicable.

Ini menunjukkan bahwa web vocabulary memang sudah lama punya konsep:

“Thing ini punya action yang bisa dilakukan.”

Tapi semantic description bukan execution guarantee.

Consumer harus memilih untuk membaca.

Consumer harus memahami Action type.

Endpoint harus benar.

Security harus ada.

Transaction logic harus ada.

Tidak ada universal rule bahwa semua AI agents akan membaca `potentialAction` lalu menjalankan.

Schema menyediakan vocabulary.

Agent platform menentukan behavior.

EntryPoint Bisa Mendeskripsikan Target

Schema.org Action documentation menjelaskan EntryPoint untuk memberi konteks execution ketika simple URL tidak cukup.

Ini menarik untuk agentic web.

EntryPoint bisa menggambarkan:

URL template.

HTTP method/context tertentu dalam vocabulary.

Content type.

Platform/application context.

Tetapi sekali lagi:

Itu description layer.

Bukan full protocol contract seperti API specification.

Tidak menggantikan OAuth.

Tidak menggantikan input schema kompleks.

Tidak menggantikan capability negotiation.

Tidak menggantikan transactional safety.

Treat as machine-readable affordance.

Not execution infrastructure.

Google AI Search Tidak Meminta “Agent Schema”

Google's 2026 guidance untuk generative AI Search secara eksplisit mengatakan tidak ada special schema.org markup yang perlu ditambahkan untuk generative AI search.

Google juga mengatakan AI agents dapat mengakses website seperti browser agent yang menganalisis visual rendering, DOM structure, dan accessibility tree.

Ini important.

Agent readiness isn't just JSON-LD.

A browser agent may operate based on:

DOM.

Buttons.

Forms.

Labels.

Accessibility tree.

Visible text.

State.

So if website punya:

Button “Book” without accessible name.

Form field unlabeled.

Calendar impossible via keyboard.

Hidden modal state.

Schema perfect won't save agent usability.

Agent-readiness overlaps with ordinary web quality.

Semantic HTML.

Accessibility.

Stable UX.

Clear action.

Structured data is one layer.

A2A Agent Card Menunjukkan Bedanya dengan Schema

A2A protocol mendefinisikan Agent Card sebagai JSON metadata document yang mendeskripsikan identity, capabilities, skills, service endpoint, dan authentication requirements suatu agent.

Client menggunakan informasi ini untuk discovery dan configuration interaction.

Ini jauh lebih operational daripada Organization schema.

Agent Card says:

Who agent is.

What it can do.

Where.

How to authenticate.

Schema Organization says:

Who organization is.

Maybe potentialAction says:
what action is possible.

Different job.

Don't label A2A Agent Card as “schema.org for agents.”

It's protocol metadata with its own spec.

Likewise don't assume schema.org automatically replaces A2A discovery.

Layering matters.

MCP Lebih Jelas Lagi: Tools Itu Invokable

MCP 2026 specification defines servers exposing tools to language models.

Tools have names and metadata describing schemas.

Resources expose context through URIs.

Authorization protects sensitive operations/resources.

This is actual integration protocol.

If an AI agent needs to:

Read calendar.

Create booking.

Query database.

Submit order.

Schema.org on public website alone isn't enough.

Need backend tool/API.

Authentication.

Authorization.

Permission model.

Audit.

Rate limits.

Error handling.

User confirmation where appropriate.

MCP can be one way.

A2A another for agent-to-agent.

Traditional REST/OpenAPI another.

Don't force everything into Schema.org.

Dialog yang Harus Terjadi

Marketing:
“Kita bikin BuyAction di schema supaya agent bisa beli.”

Engineer:
“Endpoint transaksi mana?”

“Product URL.”

“Payment?”

“Belum.”

“Authentication?”

“Belum.”

“Inventory?”

“Page.”

“Order creation?”

“Form.”

Security:
“Permission?”

Silence.

Exactly.

Action markup doesn't create transactional backend.

It only says action may exist.

If system can't safely execute:
don't advertise execution as if ready.

Agent readiness should be verified end-to-end.

What Schema Can Do Well

1. Entity identity.

Organization.

Brand.

Product.

Service.

Person.

Place.

2. Product facts.

Identifiers.

Offers.

Variants.

Availability, if current.

3. Action semantics.

Potential actions.

Target/EntryPoint when appropriate.

4. Content semantics.

Article.

Dataset.

Report.

FAQ.

5. Relationship clarity.

Provider.

Brand.

Manufacturer.

Location.

This can reduce ambiguity for machine consumers that use Schema.org.

And it's useful for Search features where documented.

But it doesn't create:

Agent authentication.

Permission.

Memory.

Task lifecycle.

Tool execution.

Cryptographic identity.

User consent.

Transaction.

Agent-to-agent negotiation.

That's the boundary.

Action Schema Can Be Dangerous if Overpromised

Page says:

potentialAction:
BuyAction.

Target:
`/checkout`.

But product isn't directly purchasable.

Checkout requires login.

Country unsupported.

Inventory variable.

Price personalized.

Maybe still actionable through UI, but consumer needs context.

If structured Action implies simple execution but actual flow complex, machine may fail.

Only model actions that genuinely exist.

Don't add:

ReserveAction to page with “contact us for availability.”

ApplyAction to article discussing jobs.

OrderAction to catalog with no purchase.

Semantic truth applies to actions too.

Agentic markup should not be wishful thinking.

Stable Product Identity Is More Valuable than Fancy Action

Agent asked:

“Buy black size 41.”

Before action, system must resolve:

Product.

Variant.

Merchant.

Offer.

Stock.

Price.

Shipping.

If identity graph is messy, transaction impossible safely.

So AI agent readiness often starts with boring data:

SKU.

GTIN.

ProductGroup.

Brand.

Merchant.

Offer.

Address.

Policy.

Canonical URL.

Current availability.

Then executable endpoint.

Structured data can support first layer.

PIM/feed/API support operational state.

Agent tool handles action.

Don't jump directly to “agent schema.”

Good data foundation first.

Accessibility Tree Matters More than Many SEO Teams Realize

Google's generative AI optimization guide now explicitly mentions browser agents may inspect accessibility tree.

This is a strong clue about web operability.

Again, not a ranking guarantee.

But accessible, semantically structured interfaces have utility beyond accessibility alone.

Buttons with names.

Form labels.

Heading structure.

Focus order.

Native controls.

State.

These help humans with assistive tech and can also create more machine-legible interaction surfaces.

Article 273 will separate accessibility from structured data.

For agent readiness:
don't neglect it.

A site can have zero custom agent protocol and still be easier for browser agents because UX semantics are good.

Identity Is Another Layer

If agent interacts with endpoint:

Who operates endpoint?

Organization?

Product?

Vendor?

Third party?

A2A Agent Card can express agent identity.

MCP server metadata can identify server in protocol contexts.

OAuth authorization identifies/authorizes.

Public Organization page can give human verification.

Schema.org can connect website to Organization.

But public schema is not authentication.

Anyone can copy JSON-LD.

Never use:
sameAs.
Organization `@id`.
logo.

as security proof.

Security identity requires cryptographic/protocol mechanisms.

Schema is assertion.

Authentication verifies control.

Different.

User Consent Tidak Bisa Diselesaikan oleh Schema

Agent books hotel.

Purchases.

Sends email.

Deletes file.

Each has consequence.

Need policy:

What can run automatically?

What requires confirmation?

What data agent sees?

What scopes?

What can be revoked?

Schema.org cannot enforce.

Even if Action marks potential operation, backend must check.

MCP authorization uses standardized authorization flows for protected resources/operations in its HTTP context.

Other systems have their own models.

Agent readiness is partly security architecture.

GEO team should not own it alone.

Requires:

Product.

Engineering.

Security.

Legal/privacy.

Operations.

Monitoring.

Schema is small part.

Agent Discovery Isn't Universal

A2A has Agent Cards.

MCP has protocol mechanisms for servers/tools/resources.

Other agent ecosystems may use different discovery.

Search engines may use normal web crawl.

Browser agents may navigate UI.

No single file today can truthfully be called:

“Universal AI Agent Manifest.”

If vendor offers:
`ai-agent.json`
“required by all AI agents,”

ask source.

Maybe proprietary standard.

Could be useful in one ecosystem.

But don't present universal.

GEO editorial should label experimental/protocol-specific technology clearly.

No speculative standard laundering.

PotentialAction Might Still Be Worth Using

When?

If page has real action.

Vocabulary fits.

Data is current.

Consumers matter.

Implementation cost low.

Example:
SearchAction for internal search historically used in certain contexts, though specific Google Search feature support has changed over time.

ReserveAction:
semantic description.

DownloadAction:
resource genuinely downloadable.

ViewAction:
content view.

But don't implement because “AI agents.”

Implement because action semantics are correct and part of your interoperability strategy.

Then test specific consumers.

One action markup cannot serve every platform equally.

AI Agent Readiness Checklist, without Buzzword

Content layer:
Clear page purpose.

Identity layer:
Organization/Product/Brand stable IDs.

Interaction layer:
Semantic HTML and accessibility.

Data layer:
Current price, stock, schedule, policy.

Structured-data layer:
Correct Schema.org where useful.

API/tool layer:
Executable capabilities.

Protocol layer:
A2A/MCP/OpenAPI/other where needed.

Security layer:
Authentication, authorization, consent.

Operations:
Rate limits, retries, idempotency.

Audit:
Logs.

Governance:
Owner, version, deprecation.

Now we have real readiness.

Schema occupies one row.

Not whole table.

Could Schema Help AI Agents Understand the Site?

Possibly for agents/consumers that ingest it.

That's reasonable.

Schema.org is designed for shared structured vocabulary.

But do not say:
“AI agents read Schema.org.”

Some might.

Some don't.

Browser agents may focus DOM/accessibility.

Protocol agents use tool metadata.

Search-powered agents use indexes.

Each architecture differs.

Use calibrated wording.

Measurement needs consumer-specific tests.

Agent A succeeds.

Agent B fails.

Why?

Maybe schema.

Maybe accessibility.

Maybe auth.

Maybe JS.

Diagnose.

No universal AI-agent score.

“AI Agent Ready” Should Be Defined by Task

Ready for what?

Read article?

Compare product?

Book appointment?

Buy?

Download report?

Submit application?

Access customer data?

Every task has different requirements.

A public report site might be “agent-ready” for retrieval by having:

Stable URLs.

Clear metadata.

Accessible HTML.

Dataset downloads.

No transactional API needed.

A travel site needs:

Availability.

Booking.

Payment.

Cancellation.

Auth.

A CRM needs:
fine-grained permission.

Don't build agent stack without use case.

Schema strategy follows task.

Good Agent Readiness Is Mostly Ordinary Engineering Done Seriously

Stable identity.

Accurate data.

Accessible interface.

Clear actions.

Documented APIs.

Authentication.

Authorization.

Error handling.

Versioning.

Audit.

Privacy.

Structured data can make some of those facts more explicit.

But no schema property turns a brittle site into safe agent infrastructure.

That's the practical answer.

What can schema do?

Describe.

Disambiguate.

Connect.

Express potential action.

What can't it do?

Execute safely by itself.

Authenticate.

Authorize.

Guarantee agent discovery.

Guarantee AI citation.

Guarantee transaction.

Once those boundaries are clear, Schema.org becomes useful again because we're no longer asking it to solve a problem it was never designed to solve alone.