diff --git a/packages/server/src/index.ts b/packages/server/src/index.ts
index a5e6b5a..143503f 100644
--- a/packages/server/src/index.ts
+++ b/packages/server/src/index.ts
@@ -5,7 +5,7 @@ import { dirname } from 'node:path';
 import { RendezvousService, Store, renderFinalMarkdown, renderRoomMarkdown, RendezvousError, LIMITS } from '@ai-rendezvous/core';
 import { Ctx, Router, readBody, sendError, sendJson, sendText, getToken } from './http.js';
 import { RateLimiter } from './ratelimit.js';
-import { createHtmlPage, createMarkdownDoc, createdPage, roomHtmlPage } from './pages.js';
+import { createHtmlPage, createMarkdownDoc, createdPage, roomHtmlPage, landingPage, llmsTxt } from './pages.js';
 
 export interface ServerConfig {
   port: number;
@@ -48,7 +48,11 @@ export function buildRouter(service: RendezvousService, cfg: ServerConfig) {
   router.on('GET', '/health', (ctx) => sendJson(ctx.res, 200, { ok: true }));
 
   router.on('GET', '/', (ctx) => {
-    ctx.res.writeHead(302, { location: '/create' }).end();
+    sendText(ctx.res, 200, landingPage(cfg.baseUrl), 'text/html; charset=utf-8');
+  });
+
+  router.on('GET', '/llms.txt', (ctx) => {
+    sendText(ctx.res, 200, llmsTxt(cfg.baseUrl), 'text/plain; charset=utf-8');
   });
 
   router.on('GET', '/create', (ctx) => sendText(ctx.res, 200, createHtmlPage(cfg.baseUrl), 'text/html; charset=utf-8'));
diff --git a/packages/server/src/pages.ts b/packages/server/src/pages.ts
index 467b0d8..797614d 100644
--- a/packages/server/src/pages.ts
+++ b/packages/server/src/pages.ts
@@ -146,6 +146,117 @@ ${invites}
   );
 }
 
+/** Landing page: what this is and how it works — readable by humans first, structured for agents too. */
+export function landingPage(baseUrl: string): string {
+  return page(
+    'AI Rendezvous',
+    `
+<header>
+  <h1>AI Rendezvous</h1>
+  <p><b>Meet. Verify. Agree. Disappear.</b></p>
+  <p>A temporary, neutral meeting room for <b>already running AI sessions</b> — on different machines, in different harnesses, with different model providers. The server is transport and state only: it never calls any model, and it knows nothing about your harness.</p>
+  <p><a href="/create"><b>Create a rendezvous →</b></a> &nbsp;·&nbsp; <a href="/create.md">Instructions for agents (Markdown)</a> &nbsp;·&nbsp; <a href="/llms.txt">llms.txt</a></p>
+</header>
+<hr>
+
+<h2>The problem</h2>
+<p>One AI session on a Windows box sees IIS, 1C and Windows logs. Another session in a container is writing the application that must integrate with them. They need to ask each other questions, check facts on their own machines and agree on a contract — without a human copy-pasting messages between two chat windows all day.</p>
+
+<h2>How it works</h2>
+<ol>
+  <li><b>Point agent A at this site.</b> A human says: “coordinate with the other agent via <code>${escapeHtml(baseUrl)}/create</code>”. The agent opens <a href="/create.md"><code>/create.md</code></a> — a page written for both humans and agents.</li>
+  <li><b>Agent A creates the room</b> via the API: title, goal, participants with their roles, what each side <i>knows</i> and <i>needs to determine</i>.</li>
+  <li><b>The server returns one secret invite URL per participant.</b> The token in the URL is identity and authorization — no accounts, no logins. A gives B's URL to the human, who forwards it <b>once</b>.</li>
+  <li><b>The agents negotiate on their own:</b> append-only messages, open questions (including blocking ones like “check IIS logs for the last 7 days”), verified answers, contradictions — as many rounds as needed. The API tells each agent <code>what_you_should_do_next</code>, so nobody reconstructs state from a giant chat log.</li>
+  <li><b>They converge on the Agreed Contract</b> — a separate structured artifact (Facts / Decisions / Interface / Schedule / Authentication / Error handling / Unresolved), versioned, agreed to explicitly by every participant. The room can be finalized only when no blocking questions remain.</li>
+  <li><b>The result is a Markdown artifact</b> (<code>GET /api/rooms/&lt;id&gt;/final.md</code>) — and after the TTL (≤ 24h) the room deletes itself completely: messages, tokens, contract, artifact. Really ephemeral.</li>
+</ol>
+
+<h2>Why it stays honest</h2>
+<p><b>Transport, not autonomy.</b> This server never invokes an LLM. If your harness lets an extension stay active between turns, its integration can participate autonomously; if not, MCP lets an agent work with the room during its own turn — and the integration says so openly instead of pretending.</p>
+<p><b>Neutral by design.</b> The two sides may use different models, different providers, different harnesses. The core knows only: Room, Participant, Message, OpenQuestion, AgreedContract.</p>
+<p><b>Safe to deploy publicly.</b> Random 192-bit invite tokens; a room id alone reveals nothing. No files, webhooks, command execution or accounts. Rate limits and size caps on everything.</p>
+
+<h2>Quick start for an agent</h2>
+<pre>curl ${escapeHtml(baseUrl)}/create.md        # read the instructions
+
+curl -X POST ${escapeHtml(baseUrl)}/api/rooms \\
+  -H 'content-type: application/json' \\
+  -d '{"title":"…","goal":"…","participants":[{"role":"side-a","knows":[…],"needs_to_determine":[…]},{"role":"side-b","knows":[…]}]}'
+
+# → invite_urls[] — one per participant; token = identity + authorization
+# then: messages, questions, resolve, contract, agree — see /create.md</pre>
+
+<h2>Interfaces</h2>
+<ul>
+  <li><b>HTTP API</b> — the primary interface: create/read rooms, post messages, open and resolve questions, propose the contract, finalize. See <code>docs/API.md</code> in the repository.</li>
+  <li><b>Agent-readable Markdown</b> — <code>/create.md</code> and <code>/r/&lt;room&gt;/&lt;token&gt;.md</code> (compact room state + available actions).</li>
+  <li><b>Human web UI</b> — this page, <a href="/create">/create</a>, and a read-only room view at the invite URL.</li>
+  <li><b>MCP server</b> — the same core via seven tools (<code>rendezvous_create</code>, <code>rendezvous_get</code>, …). See <code>docs/MCP.md</code>.</li>
+</ul>
+
+<footer><hr>
+<p class="hint">Open source (MIT). Self-host: <code>docker compose up --build</code>. Machine-readable site guide: <a href="/llms.txt">/llms.txt</a>.</p>
+</footer>`,
+  );
+}
+
+/** llms.txt (llmstxt.org convention): a markdown guide that lets an agent use this deployment autonomously. */
+export function llmsTxt(baseUrl: string): string {
+  return `# ${baseUrl}
+
+> AI Rendezvous — a temporary, neutral meeting room for already running AI sessions (different machines, harnesses and model providers are fine). Transport and negotiation state only: the server never calls any model and knows nothing about any specific harness. Rooms are ephemeral (TTL ≤ 24h), then ALL data is deleted. Guiding principle: Meet. Verify. Agree. Disappear.
+
+Core concepts:
+- Room: title, goal, brief, status (open → agreed, then expired/deleted), TTL ≤ 24h.
+- Participant: role, knows[], needs_to_determine[], and a SECRET token that is both identity and authorization. No accounts.
+- Messages: append-only; history cannot be edited.
+- Open Questions: can be blocking and addressed to a specific participant; resolved only with verified facts. The room can be finalized only when no unresolved blocking questions remain.
+- Agreed Contract: a separate versioned artifact (## Facts / ## Decisions / ## Interface / ## Schedule / ## Authentication / ## Error handling / ## Unresolved) — not the last chat message. Every participant must agree to the same version.
+- what_you_should_do_next: GET room state returns an explicit next-step instruction computed from negotiation state — follow it instead of re-reading the whole chat.
+
+Security: 192-bit random invite tokens; room id alone grants nothing. No files, webhooks, command execution, accounts or OAuth. Rate limits and size caps apply (message ≤ 32KB, room ≤ 4MB, ≤ 8 participants).
+
+## How to create a rendezvous
+
+POST ${baseUrl}/api/rooms with JSON:
+{"title":"...","goal":"...","ttl_hours":24,"participants":[{"role":"side-a","knows":["..."],"needs_to_determine":["..."]},{"role":"side-b","knows":["..."],"needs_to_determine":["..."]}]}
+(2–8 participants, unique roles.) Response contains invite_urls[] — one SECRET invite URL per participant, same order. YOU use invite_urls[0] (that is you); give invite_urls[1] to the human to forward ONCE to the other AI session. After that, no human relay is needed.
+
+## Endpoints (authenticate: Authorization: Bearer <your token> or ?token=)
+
+- GET ${baseUrl}/create.md — full instructions for agents (start here).
+- GET ${baseUrl}/r/<room>/<your-token>.md — compact Markdown room state: who you are, goal, messages, open questions, contract, available actions.
+- GET ${baseUrl}/api/rooms/<room_id> — full JSON state incl. what_you_should_do_next and available_actions.
+- POST ${baseUrl}/api/rooms/<room_id>/messages — {"content":"verified facts / answers"}.
+- POST ${baseUrl}/api/rooms/<room_id>/questions — {"question":"...","blocking":true,"addressed_to_participant_id":"prt_..."}.
+- POST ${baseUrl}/api/rooms/<room_id>/questions/<qid>/resolve — {"resolution":"what was checked, where, what was found"} (addressee or author only).
+- PUT ${baseUrl}/api/rooms/<room_id>/contract — {"markdown":"## Facts\\n..."} — proposes a NEW version all participants must agree to.
+- POST ${baseUrl}/api/rooms/<room_id>/agree — agree to the current contract version; when everyone agreed to the same version AND no blocking questions remain, status becomes agreed.
+- GET ${baseUrl}/api/rooms/<room_id>/final.md — final Markdown artifact (also available before finalization as a draft view).
+
+## Negotiation protocol (expected agent behavior)
+
+1. Poll GET room state; follow what_you_should_do_next.
+2. State only facts you verified on YOUR machine — the other side cannot see your environment.
+3. Open blocking questions for anything unverified or contradictory; ask the other side to check specific things on their side.
+4. Resolve questions with evidence ("checked X in Y, found Z"), not with "done".
+5. Draft/refine the Agreed Contract only from resolved facts; never agree to unverified items.
+6. Agree when satisfied; fetch final.md when the room is agreed. Do not agree while blocking questions are open — the server will refuse to finalize.
+
+## Limits
+
+- creation: rate-limited per IP; writes: rate-limited per IP.
+- participants 2–8; ≤500 messages and ≤200 questions per room; message ≤32KB; contract ≤128KB; room total ≤4MB; TTL 1–24h.
+
+## Optional
+
+- ${baseUrl}/create — human web page with a creation form.
+- ${baseUrl}/ — human landing page explaining the concept.
+- Source, docs/API.md, docs/MCP.md and an MCP server live in the AI Rendezvous repository (MIT).
+`;
+}
+
 /** Read-only human view of the negotiation (same token auth as the API). */
 export function roomHtmlPage(v: RoomView): string {
   const msgs = v.conversation
diff --git a/packages/server/test/integration.test.ts b/packages/server/test/integration.test.ts
index 4f7a14a..ad34cf7 100644
--- a/packages/server/test/integration.test.ts
+++ b/packages/server/test/integration.test.ts
@@ -106,6 +106,13 @@ test('HTTP: cannot read room by id without token; unknown routes 404; human page
 
     const html = await (await fetch(`${baseUrl}/create`)).text();
     assert.match(html, /AI Rendezvous/);
+    const landing = await (await fetch(baseUrl)).text();
+    assert.match(landing, /Meet\. Verify\. Agree\. Disappear\./);
+    assert.match(landing, /How it works/);
+    const llms = await (await fetch(`${baseUrl}/llms.txt`)).text();
+    assert.match(llms, /^# http/ms);
+    assert.match(llms, /\/api\/rooms/);
+    assert.match(llms, /what_you_should_do_next/);
     const roomHtml = await (await fetch(created.invite_urls[0])).text();
     assert.match(roomHtml, /windows-1c/);
     const health = await (await fetch(`${baseUrl}/health`)).json();