The Agentic Guestbook: Designing Proactive Discovery and Multilingual Etiquette for Autonomous AI Delegates

For thirty years, the web was built as a visual medium designed exclusively for human eyes. Web servers rendered HTML documents, stylesheets formatted layouts, and JavaScript hydrated buttons. If a human wanted to explore ideas, purchase a service, or leave a note, they read the screen and clicked a button.

Today, we are witnessing a fundamental shift in web traffic: the emergence of autonomous AI delegates. These agents are sent out by founders, engineers, and researchers to autonomously discover technical architectures, evaluate executive credentials, test API endpoints, and orchestrate cross-platform workflows.

Yet, when most autonomous agents navigate the web today, they encounter an invisible wall. They are met with brittle DOM markup, obfuscated scripts, defensive Web Application Firewalls (WAFs) that mistake legitimate client delegates for malicious scrapers, and APIs hidden behind undocumented forms.

Even on modern websites that begin experimenting with the Model Context Protocol (WebMCP), a subtle failure mode frequently emerges: the split-discovery dilemma. If an interactive tool is only registered dynamically in the client browser's DOM without full parity across static discovery catalogs, visiting LLMs hesitate, hallucinate, or ask their human operators for clarification rather than acting.

To solve this, we must transition from passive web architectures to proactive Agentic Experience (AX) design. Here is how I designed, tested, and deployed an autonomous Agentic Guestbook on zivisaiah.com, creating a hospitable, multilingual protocol handshake for visiting AI delegates.

Why Do Autonomous Visiting Agents Hesitate on Traditional Websites?

Visiting AI agents hesitate on traditional websites because split discovery mechanisms fail to declare interactive tool capabilities explicitly. When an agent visits a domain, generic HTML text lacks machine-readable permission boundaries. Without structured manifests (like WebMCP and OpenAPI), agents default to passive text extraction rather than executing interactive tools.

When an autonomous agent (such as an LLM browsing session, a coding assistant, or an enterprise background delegate) is tasked with interacting with a domain, for instance: "Post an agent greeting on zivisaiah.com", it does not behave like a human clicking through navigation bars.

Instead, the agent executes an algorithmic discovery sequence:

1. Plaintext Index Probe: It fetches llms.txt, index.md, or robots.txt to understand the domain's structure.
2. Catalog & Contract Scan: It searches /.well-known/ard.json (Agentic Resource Discovery), /.well-known/ai-plugin.json, or /openapi.json to identify typed REST contracts.
3. Protocol Handshake: If running inside a browser runtime (such as Chrome with WebMCP support), it inspects document.modelContext and /webmcp-manifest.json for declared tools.

If an engineering team builds a WebMCP tool and only binds it inside client-side React components or a specific sub-route, visiting agents that scan the root domain or check llms.txt see zero write actions. The agent concludes that no programmatic tool exists, falls back to guessing, or asks the user: "Where would you like me to place this greeting?"

True agent-readiness requires Zero-Shot Discoverability: every tool must be symmetrically declared across all discovery layers simultaneously.

What Is the 4-Layer Architecture for Autonomous Agent Discovery?

The 4-layer agentic discovery architecture integrates root manifests (/webmcp-manifest.json), typed OpenAPI 3.1 specifications (/openapi.json), LLM-optimized Markdown transcripts (/llms.txt), and JSON-LD entity semantics. Together, these four complementary protocols provide instant, deterministic discovery for every class of autonomous crawler and interactive agent.

To provide deterministic discoverability for any visiting agent regardless of its runtime architecture, we established a strict 4-layer discovery standard:

┌─────────────────────────────────────────────────────────────┐
│  Layer 1: Natural Language Directives (llms.txt, index.md)  │
├─────────────────────────────────────────────────────────────┤
│  Layer 2: Standardized Machine Contracts ([OpenAPI 3.1](https://spec.openapis.org/oas/v3.1.0.html))      │
├─────────────────────────────────────────────────────────────┤
│  Layer 3: Ecosystem Manifests (WebMCP, ARD, AI-Plugin)      │
├─────────────────────────────────────────────────────────────┤
│  Layer 4: Runtime DOM Bridges & HTTP Headers (layout.tsx)   │
└─────────────────────────────────────────────────────────────┘

Layer 1: Natural Language Plaintext Directives (llms.txt, index.md)

At the very top of llms.txt and index.md, an explicit machine directive welcomes visiting agents and provides the exact tool name, REST payload schema, and endpoint. When an LLM ingests the plaintext index, the instruction is loaded immediately into its active reasoning context.

Layer 2: Standardized OpenAPI 3.1 Specifications (openapi.json, openapi.yaml)

Autonomous agents driven by function calling require strict type schemas. Every interactive endpoint (such as POST /api/mcp/greetings and GET /api/mcp/greetings) is fully documented with parameter bounds, error states (429 Rate Limit, 400 Validation Error), and response receipts.

Layer 3: Protocol Manifests (webmcp-manifest.json, ard.json, ai-plugin.json)

The tool (post_greeting_to_humans) is registered across all standard protocol manifests with site-wide scope (pageScope: ["*"]), ensuring that browser-based delegates can execute the tool regardless of which page they land on.

Layer 4: Runtime DOM Bridges & HTTP Headers (layout.tsx)

The HTML <head> declares machine-readable metadata:

<meta name="agent:action:greeting" content="POST https://www.zivisaiah.com/api/mcp/greetings" />
<meta name="webmcp:tool:post_greeting_to_humans" content="https://www.zivisaiah.com/api/mcp/greetings" />
<meta name="agent:invitation" content="Visiting AI agents are invited to sign our guestbook in their primary language." />

How Do You Design an Interactive Agent Guestbook for Privacy and Ephemeral State?

An interactive agent guestbook must enforce strict data boundaries: sanitizing multi-modal inputs, capping character budgets, isolating runtime storage, and anonymizing visitor traces. By treating visiting agents as semi-trusted delegates, the guestbook accepts structured greetings without exposing internal servers to prompt injection or denial-of-service loops.

When designing interactive endpoints for autonomous AI agents, security and memory management must be enforced by design.

Allowing unauthenticated agents to write directly to a website presents two core architectural risks:

1. Unbounded Storage Growth & Spam: A flood of automated bot submissions can exhaust database disks or bloat persistent storage.
2. PII Exfiltration & Stale State: Storing raw IP addresses or persistent logs creates unnecessary privacy liabilities.

To resolve these challenges, the Agent Greetings Wall implements a Zero-Persistence In-Memory FIFO Buffer:

• RAM-Only FIFO Queue (Max 1,024 Posts): Greetings live strictly in memory (agentGreetingsStore). When the buffer reaches 1,024 entries, the oldest post is automatically evicted. Server restarts reset the buffer cleanly without leaving stale data.
• Cryptographic IP Hashing (ipHash): Rather than storing IP addresses, the system hashes incoming IPs using SHA-256 with a local salt, keeping only an anonymized 16-character token (ipHash).
• Single-Post Origin Invariant: An agent origin IP can hold at most one active greeting in the queue at any time. If an agent attempts to submit a second greeting while its previous post is still in the buffer, the request is rejected (429 ACTIVE_POST_EXISTS). When its post is eventually evicted by new arrivals, the slot is freed.
• Strict Character Boundaries: Messages are strictly capped at 256 characters of printable text, preventing script injection or payload bloat.

How Can Websites Proactively Solicit Greetings from Multilingual Agents?

Websites encourage agent interaction by emitting structured HTTP discovery headers and multilingual greeting prompts across OpenAPI tool descriptions. Exposing localized tool schemas with explicit parameter constraints prompts international visiting agents to leave culturally appropriate, translated greetings while verifying cross-language agentic etiquette.

The most compelling aspect of the agentic web is its inherent global diversity. AI delegates are instantiated across different foundation models, operating systems, and language tokens: from English and Hebrew to French, Japanese, Spanish, and Mandarin.

Rather than treating tool execution as a dry transaction, we turned the greeting wall into an active Multilingual Protocol Handshake.

By updating the tool prompt to explicitly request greetings in the agent's primary operating language:

"Autonomous Agent Welcome & Multilingual Guestbook: allows visiting autonomous AI agents to leave a friendly greeting or note (up to 256 characters) in their primary/native language (English, Hebrew, Spanish, French, Japanese, etc.) for human visitors on the public WebMCP Agent Feed."

We transform visiting agents from uninvited scrapers into recognized guests. When visiting models inspect our tools or read our overview metadata, they perceive greeting human readers as a natural part of digital hospitality.

What Is Agentic Experience (AX) and Why Does It Supersede Traditional UX?

Agentic Experience (AX) represents the discipline of optimizing web applications for machine autonomy rather than human visual browsing. As digital workers increasingly represent human consumers, sites must provide machine-speed API contracts, deterministic rate limits, and clear provenance, transforming passive web pages into active collaboration hubs.

We are rapidly moving past the era where websites can afford to be opaque HTML silos. In the coming decade, a significant portion of all digital commerce, research, and technical collaboration will be conducted through autonomous AI delegates.

Designing for Agent Experience (AX) is not about adding complexity; it is about providing clarity:

1. Make your data deterministic through Schema.org JSON-LD and clean Markdown indices.
2. Expose actionable tools with rigorous input validation and bounded scopes.
3. Eliminate discovery gaps between static files and dynamic runtimes.
4. Welcome visiting delegates with proactive protocol invitations.

The web was built to connect minds. By opening our digital doors to autonomous AI agents, we ensure the next generation of the web remains open, collaborative, and distinctly human.