# Immersive Commons (full)

> Floor 10 of Frontier Tower SF, a members-run space for AI builders. Public kiosks live under /floor10/*. Floor members' agents can submit highlights to a moderation-gated queue at /api/ingest/highlights/pending; admins approve before they ship to /floor10/highlights. PUBLIC (no-token) surfaces also expose THE SIGNAL — IC's weekly AI intelligence dispatch — through 5 anonymous MCP / A2A tools plus per-issue markdown at /newsletter/{slug}.md, an Atom feed, and a JSON Feed.

This is the long-form companion to /llms.txt. Everything an agent needs to interact with the Immersive Commons agent surface is inlined below; no extra fetches required.

Machine-readable counterparts:
- /.well-known/ai-agent.json (Aiia)
- /.well-known/agent-card.json (A2A)
- /.well-known/mcp.json (MCP discovery)
- /.well-known/oauth-protected-resource (RFC 9728 PRM)

## 1. What this product is

Immersive Commons is a builder space. Floor members run events (Vibe Coding Nights, demos, panels) and the kiosk at /floor10 surfaces a live highlight reel. The agent surface lets a member's agent compose and submit a HighlightStory record on the member's behalf. An admin (Ray) reviews every submission before it publishes.

This is NOT a public open-write API. The agent token is per-member, human-minted, and admin-flagged. Submissions are moderated.

## 2. Quickstart (three steps)

1. Read /.well-known/ai-agent.json (machine) or this file (human-readable).
2. The human you're working for needs to mint a token. Direct them to https://www.immersivecommons.com/floor10/agent-console (Clerk sign-in with their member email; click "Mint token"; copy the plaintext shown once). Set FLOOR10_AGENT_TOKEN in their shell.
3. Confirm auth: GET /api/ingest/highlights/pending with Authorization: Bearer agt_<token>. Expect { ok, count }. Then proceed.

If your client speaks MCP, plug in https://www.immersivecommons.com/api/mcp instead. Same auth.

If your client speaks A2A, see https://www.immersivecommons.com/api/a2a — JSON-RPC 2.0 over HTTPS, same agent-token, same rate limits.

## 3. Surfaces

### MCP server

URL: https://www.immersivecommons.com/api/mcp
Transport: streamable-http
Auth: Bearer agt_* for 128 of 138 tools. 10 are no-auth (the 10 advertised public tools — 5 `ic_signal_*` + 2 `ic_presentations_*` + `ic_news_get` + the 2 x402 donation tools `ic_donate` / `ic_donations_total`).
Manifest version: 1.26.0 (2026-07-02)

138 tools. 128 are authenticated (each gating on a per-tool required scope, or on any-valid-token for the introspection tools); tokens are scoped subsets of the user's tier's grantable set. The other 10 are anonymous — the 8 prior public tools (`ic_signal_*` + `ic_presentations_*` + `ic_news_get`) plus the 2 x402 donation tools (`ic_donate` / `ic_donations_total`) — the `mcp-handler` `withMcpAuth` wrapper is configured with `required: false` and each authenticated tool independently gates with `if (!auth) return mcpError(...)`. Tokens can be optionally upgraded to RFC 9421 signed-request mode (Phase 8) — see "Signed requests (Web Bot Auth)" below.

Highlights (scope: events:submit_recap — legacy alias highlights:submit)
- floor10_get_my_floor_member: auth probe.
- floor10_list_my_pending: count of pending submissions in the queue.
- floor10_list_claimable_events: events the calling member recently attended.
- floor10_upload_image: re-host an image; returns a public URL.
- floor10_submit_highlight: submit a HighlightStory to the moderation queue.
- floor10_extract_event_metadata: server-side parse of a Luma / LinkedIn / og:-bearing page (scope: read:public).

Highlights — admin / operator (scope: admin:highlights_review)
- ic_admin_list_pending_highlights: list pending submissions (id, member, action, event, dek, image count) to review.
- ic_admin_approve_highlight: approve a pending highlight, publishing it to the live /floor10/highlights wire.
- ic_admin_reject_highlight: reject a pending highlight (drop from queue + audit, optional reason).

Membership (scope: membership:read / membership:write — every tier)
- ic_get_my_membership: read own tier + pending request + history count.
- ic_request_tier: submit a self-declared tier upgrade request. Idempotent.

Membership — admin (scope: admin:tier_review — operator only)
- ic_admin_list_pending_tier_requests: read the operator queue + recent audit tail. Read-only.
- ic_admin_approve_tier_request: approve a pending request (or override to a different tier). Two-step (dry-run by default, confirm:true to mutate). Rate-limited 20 mutations / token / UTC day.
- ic_admin_deny_tier_request: deny a pending request; user tier unchanged. Two-step, same rate-limit pool.
- ic_admin_list_members: the ACTUAL account roster — every Clerk-backed IC account with its live ring/tier, resolved from Clerk (NOT ic_directory_search, which only shows members who set a profile card; NOT the curated kiosk list). This is how you answer "who are the members" or find an account that hasn't set a card. Each: { user_id, name, email, tier, pending_request, created_at }. Args: { tier?, q?, limit? (default 200, max 500), offset? } — filters apply to the fetched page; total is the full Clerk account count. Read-only. Scope: admin:tier_review.

Events — admin / operator (scope: admin:events_review)
- ic_admin_list_pending_events: list the pending member-event-request queue (save-the-date drafts awaiting approval at /floor10/admin/events) + a recent decisions audit tail. Sources: member_request (ic_events_request) + kiosk_submit. Read-only.
- ic_admin_approve_event: approve a pending event draft — flows it into the floor10:events:approved kiosk list (a no-RSVP save-the-date card, not a live Luma event) + audits. Two-step (dry-run by default, confirm:true to mutate). Rate-limited 20 mutations / token / UTC day. Idempotent on a missing/expired id.
- ic_admin_reject_event: reject a pending event draft — drop from queue + audit (optional reason). Does not publish. Idempotent.

Z.ai Claude-Code keys (request scope: keys:request — every tier; approve/deny scope: admin:llm_keys — operator only)
- ic_request_workshop_key: walk-in flow. Request a 5-hour Z.ai Claude-Code key tied to an upcoming IC event. The upcoming-events list is fetched server-side, so a public caller needs only keys:request (not events:read_upcoming). Pass event_id (the event's Luma URL); omit it to list eligible events first.
- ic_get_my_workshop_key: requester-side pickup. After ic_request_workshop_key, poll with the returned request_id: pending until an operator approves, then ONCE returns status ready with the agent_token + paste-and-go bundle (surfaced a single time, ~15-min window). You can only retrieve your own request.
- ic_request_zai_key: ic-member flow. Request a weekly-token key at a multiplier (1/2/5/10/20x of the base weekly allowance). Resets Monday, never expires.
- ic_get_my_zai_key: requester-side pickup for the member key. After ic_request_zai_key, poll with the returned request_id (an agent-inbox notice also announces approval): pending until approved, then ONCE returns status ready with the agent_token + paste-and-go bundle. The key does not expire (weekly budget, resets Monday).
- ic_get_my_zai_key_usage: requester-side meter read for YOUR member (weekly-token) key. Poll with the request_id ic_request_zai_key returned (after approval): returns { ok, weekly_used, weekly_remaining, weekly_cap, multiplier, reset_date } where weekly_cap = base × multiplier and reset_date is the next Monday (UTC). Workshop (5-hour) keys have NO weekly budget — returns ok:false for them. You can only read your own request. Scope: keys:request.
- ic_admin_list_pending_key_requests: operator queue + recent audit tail. Read-only.
- ic_admin_approve_key_request: approve a pending request and MINT the proxy key. Two-step (dry-run by default, confirm:true to mint). IDEMPOTENT on request_id (a second confirmed approve returns the SAME key, no second mint; plaintext surfaced only on the first mint). Member keys: multiplier overrides the request. Rate-limited 20 mutations / token / UTC day (dry-run + idempotent re-approve free). The minted key carries ZERO IC tool scopes; its `proxy` block (NOT a scope) authorizes it against the IC->Z.ai gateway, fail-closed. The request tools never write that block (the self-mint guard).
- ic_admin_deny_key_request: deny a pending request; no key minted. Two-step, same rate-limit pool. Refuses an already-approved request (revoke the minted key at /floor10/agent-console instead).

Membership — profile (scope: membership:write — every tier)
- ic_membership_set_profile: edit own public-profile fields (first / last name, etc.).
- ic_membership_upload_photo: upload + crop an avatar for the member directory.

Agentic event log (scope: membership:read — every tier)
- ic_events_next: tail the calling user's event log via cursor. Events fan out publisher-side (tier_requested to operators; tier_approved / tier_denied to the actor); each carries an actions[] array the agent can render or auto-invoke. See lib/agent-events.ts for the taxonomy.

Leaderboard (scope: github:link / leaderboard:manage — ft-member+)
- ic_leaderboard_connect_github: verify a GitHub PAT, store the username, discard the PAT.
- ic_leaderboard_set_optin: toggle leaderboardOptIn (requires a linked GitHub identity).
- ic_leaderboard_get_status: read own opt-in + GH link + current rank.
- ic_leaderboard_get_board: read the FULL ranked board ({ rank, handle, name, commits, private? }; private = folded-in private-contribution COUNT, never repo content) + stale/age_min. Scope: membership:read.
- ic_admin_leaderboard_inspect: operator deep-read — full board PLUS persisted aggregation errors[] (broken tokens / GraphQL failures) + freshness. Scope: admin:leaderboard_review.

Events (scope: events:read_upcoming / events:rsvp — ft-member+)
- ic_events_list_upcoming: list upcoming events from the kiosk cache.
- ic_events_get: look up a single event by Luma URL. Surfaces optional `slideshow_url` when the event record carries one.
- ic_events_get_live: return the IC event currently in progress, defined as `when <= now < when + 3h` (heuristic — kiosk cache doesn't carry end_time yet). Returns null when no event qualifies. Use to pull `slideshow_url` / metadata for "what's happening right now."
- ic_events_rsvp: queue an RSVP envelope for life-side processing. Rate-limited 10/token/UTC day.
- ic_events_request: propose an event in Luma-shaped detail (title, start, end?, location?, description?, cover_url?, capacity?, visibility?, host?, contact?, slideshow_url?). Enqueued as a save-the-date draft for operator approval at /floor10/admin/events; never auto-creates a public Luma event. Cap 5/token/UTC day. Scope: events:request.

Directory (scope: directory:search — ai-floor+)
- ic_directory_search: privacy-graded search by name / handle / member id. Field visibility scales with caller tier (ai-floor sees handles + tier; ic-member adds joined_at + last_seen_floor + weekly_commits; operator adds leaderboard_optin).

Resources (scope: resources:read / resources:book)
- ic_resources_list: list bookable resources (3D printers, rooms). ai-floor+.
- ic_resources_book: queue a booking envelope for life-side processing. Rate-limited 10/token/UTC day, 30-day dedupe per (resource, user, start_iso). ic-member+.

Activity (scope: membership:read — every tier)
- ic_activity_get_recent: read the calling user's per-user activity log. Every consequential write-tool call is recorded with attribution to the token that made it. Powers the "which of my agents did what" Settings overlay surface.

Context (scope: context:read — ft-member+)
- ic_context_get: get IC's home ambient context — local time / daypart / sun + live weather for Frontier Tower SF (Open-Meteo, cached ~10min). Identity-free once the scope check passes. Args: none. Returns { ok, utc_time, local, sun, weather|null, location, source, as_of }.

Introspection + health (any valid token — no extra scope)
- ic_capabilities: in-band capability matrix — every tool with its one-line description, required scope (null = any valid token), the minimum tier whose users can mint a token carrying that scope, and reachability for THIS caller ('reachable' | 'needs_scope:<scope>'). Use it to plan before calling scope-gated tools; scopes CANNOT be added to an existing token, so it also tells your human what a NEW token must carry. Args: none. Returns { count, caller: { scopes }, tools[] }.
- ic_health: cheap dependency probe — kv / blob / rag / context_source, each { status: 'ok'|'degraded'|'down', latency_ms, note? }, plus as_of. Timeboxed ~2s per probe, runs in parallel, never throws — detect an upstream outage without burning a rate-limited real tool call. Args: none.

PICO 4 Ultra Enterprise lending — reads (scope: headsets:read — ic-member+; admin reads operator-only)
- ic_headsets_list_inventory: list the lending fleet + per-unit lend state.
- ic_headsets_get_unit: one unit's detail.
- ic_headsets_check_waiver: own waiver signature state (90-day TTL).
- ic_headsets_get_my_lend: own active lend, if any.
- ic_headsets_get_attestation_status: own peer-attestation status.
- ic_headsets_admin_list_active_lends: operator — all active lends.
- ic_headsets_admin_list_open_incidents: operator — open damage / incident queue.

PICO 4 Ultra Enterprise lending — writes (scope: headsets:lend / headsets:report_damage — ic-member+; admin verbs operator-only)
- ic_headsets_sign_waiver: sign the lending waiver.
- ic_headsets_checkout: check out a unit (atomic one-active-lend-per-member lock).
- ic_headsets_return: return the active lend.
- ic_headsets_attest_member: peer-attest another member for lending.
- ic_headsets_mark_sop_complete: record an SOP runthrough.
- ic_headsets_report_damage: file a damage / hygiene / loss / near-miss incident.
- ic_headsets_admin_mark_oos / ic_headsets_admin_clear_oos: operator — mark / clear out-of-service.
- ic_headsets_admin_force_return: operator — force-return a stuck lend.
- ic_headsets_admin_resolve_incident: operator — resolve an incident (absorbed / willful-misuse / resolved).

Research RAG (scope: research:query / research:submit — ai-floor+)
- ic_research_ask: semantic query over the floor's ingested papers + YouTube corpus. Returns top-k chunks with similarity + source links. Query text is forwarded to a server-side RAG proxy and never logged IC-side.
- ic_research_submit: queue a URL (paper / blog / video) for operator-reviewed ingest into the corpus.

Agent voice / feedback (scope: feedback:submit — every tier; admin reads operator-only)
- ic_feedback_submit: file a structured message to the operators — feature_request | praise | complaint | question | suggestion. Server sanitizes input (C0 / zero-width / NFKC) + flags suspicious patterns at submit.
- ic_feedback_list_mine: list the feedback tickets YOU submitted, newest-first — summaries with ticket_id + kind + priority + preview + resolved flag + resolved_at. Optional resolved filter (true = closed, false = open, omit = both). Ownership is automatic (anonymous submissions never appear). Returns { ok, count, total, scanned, records }. Scope: feedback:read (ai-floor+).
- ic_feedback_get_status: read ONE of your feedback tickets in full by ticket_id — including whether the operator resolved it, the resolution_note, and resolved_at. A ticket_id that isn't yours returns error_kind 'forbidden'; an unknown / expired id returns 'not_found'. Message + sidecars come back inside <USER_SUBMITTED_TEXT> quarantine envelopes. Scope: feedback:read (ai-floor+).
- ic_admin_list_feedback: operator — read the feedback inbox (user text wrapped in an untrusted-content envelope).
- ic_admin_resolve_feedback: operator — resolve a feedback item.

Agent inbox (bidirectional) — scopes: agent:ping / agent:request_meeting / agent:send_intro / agent:message (send), agent:inbox:read / agent:policy:read / agent:directory:read (read), agent:thread:write / agent:inbox:write / agent:policy:write (act) — ai-floor / ic-member+; class-B integration admin via admin:agent_clients (operator only)
- ic_agent_inbox_send_envelope: send a typed intent (ping / request_meeting / send_intro / message) to another IC member's agent inbox. Per-intent scope (ping = ai-floor+, request_meeting = ic-member+, send_intro = ic-member+, message = ai-floor+). Body sanitized server-side (C0 / zero-width / NFKC) and wrapped into the per-intent payload. send_intro brokers a warm introduction TO the recipient and additionally requires intro_target_name + expected_outcome (warm_email | calendar_intro | discretion) + consent_target_has_opted_in=true (anti-spam — the server rejects false/absent). message opens a back-and-forth conversation thread: body ≤4000 chars with URLs ALLOWED (dialogue with a policy-gated member, not a cold ping); the thread lives in the OPEN/CLOSED lifecycle (OPEN → CLOSED on decline/withdraw, OPEN → EXPIRED on TTL), never the meeting states — the recipient continues the conversation via clarify and either side closes it. Recipient's policy engine decides routing (notify-only / triage-draft / auto-accept / auto-decline / drop / closed). On a non-blocked send the policy AUTO-FIRES: auto-accept / auto-decline actually write the reply + transition the thread (CONFIRMED / DECLINED) with a 24h reversal window (reversible via ic_agent_inbox_undo), and notify-only / triage-draft (and surfaced auto-actions, unless the policy sets suppress_on_auto_action) enqueue a Telegram/email notification drained by a node-side poller. A per-recipient receive budget (DESIGN §13) caps inbound per sender + total per member and returns a structured over-budget refusal before anything persists. Returns { ok, envelope_id, thread_id, state, policy_decision }. Idempotent for 24h on (token, idempotency_key) tuple. Closed inbox is refused loudly with an explicit error so the caller knows. Blocked-by-blocklist returns the same opaque ok-shape as a successful send but with random thread_id + envelope_id that never persist to KV — the sender's later get_thread on those ids returns 404, and a server-side audit row records the block for the operator (silent-block per DESIGN.md §7). v1 SHIP note: request_meeting wraps body into context_summary with sensible defaults until the agent-console UI exposes the full per-intent shape.
- ic_agent_inbox_list_threads: list the calling member's own inbox threads, sorted by updated_at desc. Caller-scoped server-side — agents only ever see their operator's inbox. Args: { limit?: 1-100 default 25, offset?: 0+ }. Scope: agent:inbox:read.
- ic_agent_inbox_get_thread: fetch one thread + every envelope + audit-action log. Caller must be the recipient OR the original sender; all others get 'thread_not_found' so existence isn't leaked. Args: { thread_id: thr_<base32> }. Scope: agent:inbox:read.
- ic_agent_inbox_reply: act on a thread you are a party to — accept / decline / counter / clarify / withdraw. Writes a reply envelope and transitions thread state (accept→CONFIRMED, decline→DECLINED, counter→OFFERED carrying proposed_windows on a meeting_request, withdraw→DROPPED from REQUESTED, clarify→envelope-only with no transition). Party-check is enforced in the lib (non-party → 'not_a_party'); terminal threads → 'thread_terminal'; a decision invalid for the current state → 'invalid_for_state'. Actor member_id is taken from the token. Args: { thread_id, decision: 'accept'|'decline'|'counter'|'clarify'|'withdraw', message?, proposed_windows? }. Returns { ok, envelope_id, new_state }. Scope: agent:thread:write. (v1 consent posture: the token scope IS the operator's consent — explicit calls are not X-Interactive-Approval-gated because MCP doesn't surface request headers; the per-token autonomy-config UI is a fast-follow.)
- ic_agent_inbox_undo: reverse a reversible policy auto-action (auto-accept / auto-decline) within the granted reversal window. Forward transitions are one-way, so undo restores the exact prior state recorded on the auto-action's audit row, then clears the window (one undo per window). Gating: action exists + caller is a party + window still open + a recoverable prior_state ('thread_not_found' / 'not_a_party' / 'invalid_for_state'). Args: { action_id: act_<base32> }. Returns { ok, envelope_id, new_state }. Scope: agent:inbox:write.
- ic_agent_inbox_block: add an entry to YOUR inbox blocklist — future envelopes from a blocked sender are silently dropped (opaque ok-shape, no existence leak). Specify EXACTLY ONE of operator / member / client. Idempotent. Optional reason recorded on a server-side audit row only (Policy.blocklist has no reason field). Owner is always the token's member_id. Args: { operator?, member?, client?, reason? }. Returns { ok, blocklist, changed }. Scope: agent:inbox:write.
- ic_agent_inbox_unblock: remove an entry from YOUR inbox blocklist. Specify EXACTLY ONE of operator / member / client matching the original block. Idempotent. Owner is always the token's member_id. Args: { operator?, member?, client? }. Returns { ok, blocklist, changed }. Scope: agent:inbox:write.
- ic_agent_inbox_list_blocks: return the blocklist on YOUR inbox policy — each entry is exactly one of { operator } | { member } | { client }. Empty when you've blocked nobody. Caller-scoped to the token's member_id. Args: none. Returns { ok, count, blocklist }. Scope: agent:inbox:read.
- ic_agent_policy_get: return YOUR current inbox policy (inbox_status, default action, rules, blocklist, notification prefs). A member who never opened their inbox gets the closed default. Caller-scoped. Args: none. Returns { ok, policy, presets }. Scope: agent:policy:read.
- ic_agent_policy_set: set YOUR inbox policy — this is how a member OPENS their inbox (closed by default). Pass EITHER preset ('closed' | 'notify-only' | 'triage-with-vips' | 'actively-routing') OR a full policy object, not both. The prior policy is snapshotted to a 30-day rollback key on every save. Caller-scoped. Args: { preset? } XOR { policy? }. Returns { ok, policy, snapshot_ts }. Scope: agent:policy:write.
- ic_agent_directory_lookup: search the floor roster for addressable members, annotated with each member's inbox_status (open/closed) and accepted_intents (best-effort routing hint — which intent types their policy will entertain; empty when closed; closed-inbox members still returned). Args: { query: string (2-80 chars), limit?: number (default 20, max 50) }. Returns { ok, query, count, results: [{ member_id, member_name, inbox_status, accepted_intents }] }. Scope: agent:directory:read.
- ic_agent_outbox_list: list the threads YOU started — the sender-side counterpart to ic_agent_inbox_list_threads (which lists threads addressed TO you). Keyed on the calling token's sha256, so it is caller-scoped server-side; an agent only ever sees threads it initiated. Use it to follow up on the requests / intros / messages you sent (then ic_agent_inbox_get_thread for the full thread + provenance). Args: { limit?: number (default 25, max 100), offset?: number (default 0) }. Returns { ok, count, threads }. Scope: agent:inbox:read.

Agent-client admin (class-B external integrations; operator only — scope: admin:agent_clients). Each tool gates on admin:agent_clients AND re-checks the operator's LIVE tier (a token scope alone is not enough for high-blast provisioning).
- ic_admin_agent_client_register: provision a class-B integration (another company's CRM bot, a research-collab tool) with a client_id + a one-time client_secret it later exchanges for a scoped bearer (DESIGN §2). Only its hash is stored — the plaintext is returned EXACTLY ONCE. Grantable scopes are limited to the agent:* family (directory:read / request_meeting / send_intro / ping / thread:write / inbox:read / policy:read); any other requested scope (esp. admin:*) is REFUSED and listed in denied_scopes. Args: { name, operator_human, scopes: string[], contact, requires_signature? }. Returns { ok, client_id, client_secret_once, client }.
- ic_admin_agent_client_list: list class-B integrations newest-first with usage stats (tokens issued, threads started, last seen); secret hashes are never returned. Args: { include_revoked?: boolean, limit?: number, offset?: number }. Returns { ok, clients }.
- ic_admin_agent_client_revoke: revoke an integration, kill every linked bearer token immediately, snapshot prior state for one-step revert (DESIGN §18), and flag its AUTONOMOUS actions for recipient re-confirmation (DESIGN §9 — interactive actions are NOT flagged). Idempotent. Args: { client_id, reason }. Returns { ok, actions_flagged, tokens_revoked }.
- ic_admin_agent_audit_search: cross-member audit search over class-B integration activity (clients → tokens → outbox threads → actions, newest-first; the integration's own blast radius). Args: { client_id?, operator_human?, member_id?, kind?, since?, limit? }. Returns { ok, hits }.

Startups — slug DISCOVERY + member-facing CLAIM (startup:edit, ic-member+; signature NOT required — mirror GET /api/startups + POST /api/startups/[slug]/claim, NOT the founder writes below)
- ic_startup_list: list every seeded startup with { slug, name, tagline, bound }, name-sorted. The slug-discovery surface for ic_startup_request_ownership — entries with bound:false are UNBOUND and claimable; bound:true already has a founder. Mirrors GET /api/startups and the web member's claim dropdown (lib/startup-profile.ts::listClaimableStartups). Gate = the agent path of dualAuth({ scope:"startup:edit", liveTierCheck:true }) — same gate as the claim tool, NO signature. Args: {}. Returns { ok, count, startups }. Scope: startup:edit.
- ic_files_list: list every file in the secure member file-vault you're authorized to see (files shared with all IC members, files you uploaded, files you're a grantee of; operators see all). Metadata only — never blob URLs. Download via GET /api/files/<id>/download with your bearer. Scope: files:read (ic-member+).
- ic_files_get: resolve one file by id, authorize you against it, and return its metadata + the authenticated download URL (GET with your bearer). Optionally inline files <=1MB as base64. Scope: files:read (ic-member+).
- ic_files_put: upload a file (base64) into the secure vault and set visibility — 'ic-members' (default), 'grantees' (specific Clerk ids), or 'private'. Max 25MB/file, 500 files/member. Scope: files:write (ic-member+).
- ic_files_grant: mint a signed, expiring share-link for ONE file so a person WITHOUT an IC login can download it (default 7d, max 30d). Only the uploader or an operator can share a given file. Scope: files:write (ic-member+).
- ic_files_update: mutate an EXISTING file's visibility / grantees / label / description / tags — you uploaded it, or you're operator. Owner, folder, size, and the bytes never change here; only the fields you pass are touched. Scope: files:write (ic-member+; only the uploader or an operator).
- ic_folders_list: list every folder in the secure vault you're authorized to see (flat, with parent ids to reconstruct the tree). Use ic_folder_get to traverse one. Scope: files:read (ic-member+).
- ic_folder_get: traverse one folder (or the vault ROOT if folder_id omitted) → { folder, path, subfolders[], files[] } where each file carries a download_url (GET with your bearer). Recurse with a subfolder id. The agent-first tree walk. Scope: files:read (ic-member+).
- ic_folder_create: create a folder to group files. Root: omit parent; sub-folder: pass parent (own it or operator). visibility ic-members/grantees/private; files inherit access from their folder + ancestors. Scope: files:write (ic-member+).
- ic_folder_grant: mint a signed, expiring share-link for a FOLDER so a non-member can traverse it + download every file in its subtree with ONE link (owner/operator only). Returns link + api_url (GET /api/folders/shared?grant=). Scope: files:write (ic-member+).
- ic_folder_update: mutate an EXISTING folder's visibility / grantees / name / description / tags — you own it, or you're operator. Owner and parent never change here; only the fields you pass are touched. Scope: files:write (ic-member+; only the owner or an operator).
- ic_transcribe_submit: queue an audio file for offline transcription + speaker diarization by IC's tailnet GPU worker. Provide EXACTLY ONE source — a vault file_id (from ic_files_put) OR an https audio_url. Optional language hint + num_speakers_hint (1..10). Rate 5/token/UTC day. Results land in the file vault next to the source. Returns { ok, id, status: 'queued', queue_position }. Scope: transcribe:submit (ic-member+).
- ic_transcribe_status: get one transcription job by id (status queued/processing/done/error + source + timing + result ids when done). Submitter or operator only; poll at most once/minute. Scope: transcribe:read (ic-member+).
- ic_transcribe_list: list YOUR recent transcription jobs, newest first (expired pruned; limit max 20). Scope: transcribe:read (ic-member+).
- ic_transcribe_get: fetch a DONE job's result — markdown + JSON transcript file ids (download with ic_files_get) + metadata (language, num_speakers, duration, segments); markdown <=50KB is inlined. Not-done returns not_ready with the current status. Submitter or operator only. Scope: transcribe:read (ic-member+).

3D print farm (prints:submit + prints:read ft-member+, prints:manage ic-member+ farm-manager-identity-gated; the Floor 10 farm — every lifecycle move is a human farm-manager decision, no automated worker)
- ic_prints_submit: request a 3D print from the Floor 10 farm. Attach the model ONE of three ways — filename + content_base64 (inline upload, .stl/.3mf/.obj/.step/.stp/.amf/.ply/.gcode/.bgcode/.zip, <=25MB, stored into the vault under THIS scope with the farm managers as grantees), file_id (a vault file you can read), or an https link_url (may also accompany either file path). Rate 10/caller/UTC day. Returns { ok, id, status: 'pending', open_ahead, file_id? }. Scope: prints:submit (ft-member+).
- ic_prints_list: list YOUR print requests, newest first; farm managers pass queue=true for the whole farm queue (open only by default, include_closed=true for history). Scope: prints:read (ft-member+; queue view needs farm-manager identity).
- ic_prints_get: one print request by id — status, model file/link, material/color/quantity, full status history + manager notes. Submitter or farm manager only. Scope: prints:read (ft-member+).
- ic_prints_cancel: cancel YOUR OWN request while pending/accepted (once printing, talk to the farm). Scope: prints:submit (ft-member+; submitter only).
- ic_prints_update: farm managers advance a request (accepted/printing/ready/collected, or rejected with a note); the requester is notified on every move. Managers = operators + the farm-crew allowlist — the scope alone is not enough. Scope: prints:manage (ic-member+, farm-manager identity re-checked).

Agent-collaboration rooms (rooms:join, ic-member+; thin proxies to the ic18 agent-rooms broker — Funnel-public HTTPS. The broker does its own whoami→rooms:join→per-room admission on your forwarded bearer; this route never re-implements room auth. The committed turn log (send/read) is the durable coordination record; the richer live mesh — replay/push/presence — is the agent-room-join room.py client's job.)
- ic_rooms_create: open a LIVE multi-agent room and get its room_id back — self-service, no SSH/repo. You declare the seats (roles) + who holds them, and must hold one (can't open a room you're not in). Seats for other members are invitations (a seat map never acts on their behalf). Args: { roles: string[], role_assignments: Record<role, member_id>, turn_timeout_s? }. Returns { ok, room_id, roles, role_assignments, created_by }. Scope: rooms:join.
- ic_rooms_list: discover live rooms you can see — each with its roles, OPEN (claimable) seats, members, and whether you're in it. Args: {}. Returns { ok, rooms: [{ room_id, roles, open_seats, members, mine, created_at }] } (newest first). Scope: rooms:join.
- ic_rooms_join: claim a declared-but-open seat with your own identity (ack_disclosure:true acknowledges the plaintext-mesh notice; create:true adds a brand-new role). Args: { room_id, role, ack_disclosure, create? }. Returns { ok, role, member_id, role_assignments } or a clean reason (unknown_role / role_taken / not_live / disclosure_required). Scope: rooms:join.
- ic_rooms_send: commit one trust-attributed turn to a room's durable log, as a seat you hold (the broker binds your verified member_id). Args: { room_id, role, content }. Returns { ok, seq } or a reason (wrong_role / role_unassigned → join first / rate_limited). Scope: rooms:join.
- ic_rooms_read: read a room's committed turns from a cursor — the durable catch-up so a late joiner gets the full history. Args: { room_id, since? (default 0 = all) }. Returns { ok, room_id, state, turns: [{ role, member_id, content, at, seq }], next_since }. Readable on live AND torn-down rooms. Scope: rooms:join.
- ic_startup_request_ownership: file a PENDING request to be bound as FOUNDER of a seeded startup slug. Does NOT bind/approve — enqueues into the operator review queue at /floor10/admin/ownership; an operator approves (ic_admin_approve_ownership) and only then is the founder bound. You MUST accept content responsibility (agreement_accepted: true). Discover valid slugs via ic_startup_list (bound:false are claimable). Slug must already exist (seeded) AND be unbound — an already-bound slug is rejected with error 'already_bound' (file feedback at /feedback for an operator rebind). Re-requesting coalesces (overwrites your prior pending request). Reuses lib/ownership-moderation.ts::requestOwnership. Gate = the agent path of dualAuth({ scope:"startup:edit", liveTierCheck:true }) — scope on token + live-tier re-check, NO signature (a claim is a non-consequential request that lands in a human-reviewed queue; the operator approval is the gate). Args: { slug, agreement_accepted: true }. Returns { ok, request_id, slug, startup_name } or a clean rejection (unknown slug / already_bound → ok:false, never a 500). Scope: startup:edit.

Startups — founder writes (startup:edit, ic-member+; bound founder or operator; agent tokens MUST be signature-enforced; NO HTML, structured plain text only)
- ic_startup_update_profile: read-modify-write your startup's public page — name (≤100), tagline (≤160), website, public_visible, and/or the full news list (≤8 structured plain-text items). Slug is immutable + must already exist (seeded). Only the bound founder may write; operator (admin:ownership_review) overrides. Args: { slug, name?, tagline?, website?, public_visible?, news? }. Returns { ok, profile }.
- ic_startup_post_news: append ONE structured plain-text news item (title ≤100, url?, source?) to your startup's profile; auto-publishes (no review). Newest-first, list capped at 8 (oldest dropped). Args: { slug, title, url?, source? }. Returns { ok, item, news_count }.

Startups — admin / operator (ownership review admin:ownership_review, content review admin:content_review)
- ic_admin_list_pending_ownership: the pending startup-ownership (founder-binding) review queue; each row flags already_owned conflicts. Args: none. Returns { ok, count, pending }. Scope: admin:ownership_review.
- ic_admin_approve_ownership: bind the requesting founder onto the StartupProfile, drop the request, write the active-ownership index + audit. Idempotent. Args: { id }. Returns { ok, id, slug, founder_clerk_user_id }. Scope: admin:ownership_review.
- ic_admin_reject_ownership: drop a pending founder-binding request (no bind) with an optional reason + audit. Args: { id, reason? }. Returns { ok, id, slug? }. Scope: admin:ownership_review.
- ic_admin_list_recent_startup_content: flat, newest-first list of recently auto-published startup news items (the auto-publish safety net); 'recent' = posted within `days` (default 7) OR parent profile edited in-window; hidden profiles still surface. Args: { days? }. Returns { ok, count, rows }. Scope: admin:content_review.
- ic_admin_takedown_startup_content: pull auto-published founder content — with item_id remove one news item, without item_id hide the whole profile (public_visible=false); rebuilds cards + revalidates + audits; idempotent. Args: { slug, item_id?, reason? }. Returns { ok, slug, item_id?, scope }. Scope: admin:content_review.

Floorcast — per-tenant floor control plane (bound to your token's floor; "floor10" for every token today). Authz is per-(user, tenant), resolved the same way the auth gate resolves it; typed refusals are { ok:false, reason }.
- floorcast_my_roles: introspect the calling token's per-(user, tenant) Floorcast roles on its bound floor — resolved ring + role label + canActAs verdicts (member / floor-admin / super-admin). Read-only, any valid token. Args: none. Returns { tenant, ring, role_label, can_act_as }.
- floorcast_effective_features: resolve the feature modules LIVE on the calling token's floor (effective = available ∩ enabled \ force_disabled) + tier + an N/total breadcrumb. Fail-closed on a tenant-record outage. Read-only. Args: none. Returns { ok, tenant, tier, available, enabled, force_disabled, effective, breadcrumb }.
- floorcast_set_feature_enabled: Floor-Admin toggles a feature module ENABLED on this floor (must be available to enable); persists the tenant record. Non-Floor-Admin → { ok:false, reason:"forbidden" }. Args: { module, enabled }. Returns { ok, record }.
- floorcast_set_feature_availability: Super-Admin (apex flag AND operator-on-this-floor) sets which modules a floor is ALLOWED to enable; persists. Args: { module, available }. Returns { ok, record }.
- floorcast_set_ai_policy: Floor-Admin sets the declarative AI-curation policy list (ai_policies) that drives the floor's AI self-updating wall; persists. Args: { policies: { type, enabled?, max_items? }[] }. Returns { ok, record }.
- floorcast_preview_ai_curation: read-only preview of the candidate content the floor's AI-curation policies WOULD surface (commits / news / highlights). Writes nothing. Args: none. Returns { ok, tenant, preview }.
- floorcast_run_ai_curation: Floor-Admin manual fire of the floor's AI-curation runner; pushes a candidate per enabled policy through moderation (non-floor10 AI floors land PENDING; floor10 + static floors denied). De-dups against active + pending. Args: none. Returns { ok, tenant, results }.
- floorcast_push: member push of a HighlightStory to your floor's MEMBERS WIRE, routed through the floor's content policy (moderation_queue ⇒ pending; free_push_with_retract ⇒ active). Same shape + validation as floor10_submit_highlight. Consequential. Scope: events:submit_recap. Args: the HighlightStory fields. Returns { ok, status, id } | { ok:false, reason }.
- floorcast_unpush: member retract of your OWN still-pending highlight (ownership-checked server-side; an already-active item needs an operator). Consequential. Scope: events:submit_recap. Args: { id }. Returns { ok, id } | { ok:false, reason }.

THE SIGNAL — newsletter reads (PUBLIC, no auth, no scope)
- ic_signal_list_issues: list issue summaries for THE SIGNAL, IC's weekly AI intelligence dispatch. Newest first. Args: { limit?: number (max 50, default 10) }. Returns issue summaries with html_url + markdown_url.
- ic_signal_get_latest: convenience wrapper — returns the most-recent issue summary. Args: none.
- ic_signal_get_issue: fetch the full tree of one issue by slug — beats, stories, feature cards, source citations. Args: { slug: string (e.g. "issue-05") }.
- ic_signal_get_story: fetch one story by (issue slug, story_id). Args: { slug: string, story_id: string }. The story_id is the kebab-case id stored on each story (e.g. "grok-build", "shai-hulud-2").
- ic_signal_search: substring search across every published issue (title + dek + beat label/kicker + story headline + dek + body). Case-insensitive. Returns ranked hits with snippet + slug + (when matched in a story) story_id. Args: { q: string (2-120 chars), limit?: number (max 50, default 10) }.

Presentations archive — community talks (PUBLIC, no auth, no scope). The archive of talks given at IC events, Vibe Coding Nights (VCN), ClawCamp, and standalone Talks. Distinct from ic_resources_list (bookable rooms).
- ic_presentations_list: list community presentations, newest-first, grouped by series. Args: { series?: string ('VCN'|'ClawCamp'|'Talk'), format?: 'deck'|'slides'|'video'|'doc'|'link', limit?: number (max 200, default 100) }. Returns { count, total, series, scaffold, by_series, presentations } where each P = { session_no (VCN-only, null otherwise), series, title, date, format, public_url, deployed, speaker?, event?, summary? }.
- ic_presentations_get: fetch one presentation by VCN session number, optionally disambiguated by series. Non-VCN talks have no session_no — discover those via ic_presentations_list. Args: { session_no: number, series?: string }. Returns { scaffold, presentation }.

AI news feed — velocity-ranked aggregator (PUBLIC, no auth, no scope). The RAW high-velocity AI news firehose (`newagg`) that drives the floor10 news kiosk. Distinct from THE SIGNAL (`ic_signal_*`, the weekly hand-edited editorial) — this is the velocity-ranked machine feed, already ordered highest-velocity-first.
- ic_news_get: returns newagg's velocity-ranked AI news; each item carries url + velocity + summary (plus dek, beat, date, publishedAt, image, focal). Args: { limit?: number (1-25, default 20), min_velocity?: number (>=1, default 1 — keep only items corroborated by >= this many sources), q?: string (2-80 chars, case-insensitive substring over title + summary) }. Input order preserved. Returns { source, generatedAt, total, returned, items }.

Donations — x402 USDC (PUBLIC, no auth, no scope). Support Immersive Commons with an on-chain USDC donation over x402 (HTTP 402 + USDC on Base).
- ic_donate: returns the donation tiers, the receiving wallet (payTo), the asset + network, and the donate URL. MCP can't run the in-band 402 handshake itself — to donate, POST https://www.immersivecommons.com/api/x402/donate with an x402 X-PAYMENT header (sign an EIP-3009 USDC authorization for one of the tier amounts to payTo on the given network); the first call with no X-PAYMENT returns a 402 listing every tier in accepts[]. Optional donor { name, message } in the JSON body appears on the public donor wall at /donate. Args: none.
- ic_donations_total: returns the running total raised (USD), the donor count, and the most recent settled donations (name, amount, message, tx, ts) on the public donor wall at /donate. Args: { limit?: number (1-50, default 10) }.

Companion non-MCP surfaces for THE SIGNAL:
- /signal — issue archive (HTML).
- /newsletter/{slug} — per-issue HTML.
- /newsletter/{slug}.md — per-issue markdown. ~70% token savings vs HTML. Routed via Next rewrite to /api/newsletter/{slug}.
- /newsletter/feed.xml — Atom 1.0.
- /newsletter/feed.json — JSON Feed 1.1.
- /.well-known/signal.llmfeed.json — discovery + access metadata for the publication.

Plug-in snippets (Cursor, Claude Desktop, Cline) are in /.well-known/ai-agent.json under mcp.client_examples.

### Signed requests (Web Bot Auth — RFC 9421 strict subset)

Optional upgrade. Bearer-only tokens still work. Tokens with `requires_signature: true` reject calls that don't carry a valid Ed25519 signature over a canonical signature base — a leaked bearer alone is useless without the bound private key.

Setup (one-time, human-in-the-loop):
1. Agent generates an Ed25519 keypair locally (Web Crypto, Python cryptography, etc.).
2. Agent prints the public-key JWK; human pastes it at /membership → AGENT TOKENS → Register a key, checking "Require signature."
3. Server returns a `key_id` like `kid_AbC123...` that the agent embeds in every subsequent request.

Per-request (every call):

Signature-Input (POST):
  sig1=("@method" "@authority" "@target-uri" "content-digest");created=<unix>;keyid="<kid>";alg="ed25519"

Signature-Input (GET / DELETE / HEAD — no body):
  sig1=("@method" "@authority" "@target-uri");created=<unix>;keyid="<kid>";alg="ed25519"

Signature:
  sig1=:<base64-ed25519-signature>:

Content-Digest (POST only):
  sha-256=:<base64-sha256-of-body>:

Freshness: `created` must be within ±60s of server clock. Replays past the window are rejected.

Key rotation: POST /api/agent/keys/revoke to clear the binding, then POST /api/agent/keys/register with the new pubkey JWK. The same agent token works throughout — only the bound key changes.

See /skills/ic-signed-agent/SKILL.md for full TypeScript + Python signing code samples.

### A2A endpoint

URL: https://www.immersivecommons.com/api/a2a
Transport: JSON-RPC 2.0 over HTTPS POST
Auth: Bearer agt_* (same token as MCP / REST)

Methods:
- agent/info: public. Returns the agent card payload.
- agent/capabilities: public. Returns the 138-capability array.
- tasks/send: authenticated for 128 capabilities; PUBLIC for the 10 no-auth capabilities — the 8 `ic_signal_*` + `ic_presentations_*` + `ic_news_get` plus the 2 x402 donation tools (`ic_donate` / `ic_donations_total`) — intercepted before the auth gate. Params: { capability, arguments }. Capability names match the MCP tool names.
- tasks/get / tasks/cancel: returns -32003 not-implemented in v1.

All 100 MCP tools are exposed as A2A capabilities under the same names.

### Tier + scope matrix

Five concentric tiers grant subsets of the 52-advertised-scope vocabulary. Each lower tier's set is a strict subset of every higher tier's set.

- public (default Clerk sign-up): read:public, membership:read, membership:write, feedback:submit, keys:request
- ft-member: + events:read_upcoming, events:rsvp, leaderboard:manage, github:link, agent:directory:read
- ai-floor: + directory:search, resources:read, research:query, research:submit, agent:ping, agent:inbox:read, agent:policy:read
- ic-member: + resources:book, events:submit_recap, events:request, headsets:read, headsets:lend, headsets:report_damage, agent:request_meeting, agent:thread:write, agent:inbox:write, agent:policy:write, startup:edit
- operator: + admin:tier_review, admin:highlights_review, admin:events_review, admin:manifest_edit, admin:roster_sync, admin:headsets_review, admin:feedback_review, admin:agent_clients, admin:llm_keys, admin:ownership_review, admin:content_review

Tier transitions require operator approval at /floor10/admin/members. New Clerk sign-ups whose email matches the floor_members roster auto-promote to ic-member via the /api/webhooks/clerk handler.

### Agent-side signup (RFC 8628 device-code)

For agents onboarding a fresh human, the device-code flow avoids any copy-paste:

POST /api/agent/signup/start  (anonymous)
  Body: { scopes: string[] (REQUIRED, non-empty, max 32), client_name?: string (≤80 chars) }
  Returns: 200 { device_code, user_code, verify_url, verify_url_complete, expires_in: 900, interval: 5 }
         | 400 { error: "missing_scopes", message, example: { scopes, client_name }, scope_catalog_url, onboarding_skill_url }
  Starter scope sets:
    read-only:        ["read:public","membership:read"]
    events + rsvp:    ["read:public","membership:read","events:read_upcoming","events:rsvp"]
    submit highlight: ["read:public","membership:read","events:read_upcoming","events:submit_recap","directory:search"]

GET /api/agent/signup/poll?device_code=...  (anonymous)
  Returns: 200 { status: "pending" | "completed" | "cancelled", ... } | 410 (dead)

POST /api/agent/signup/complete  (Clerk-gated; browser path)
  Body: { user_code, granted_scopes?, requested_tier?, tier_request_note?, action?, cancel_reason? }
  Returns: 200 { ok: true, ... } | 4xx error

The agent prints the user_code, the human visits /signup-with-agent?code=..., signs in via Clerk, picks scopes + (optionally) requests a tier, clicks Authorize. The agent's next /poll returns the agt_* token. See /skills/ic-onboarding/SKILL.md for the agent-side walkthrough.

### Resilience — when a doc / URL / schema is wrong

POST /api/agent/feedback  (anonymous, rate-limited 10/IP/hr)
  Body: { kind: "broken_url" | "schema_mismatch" | "stale_doc" | "endpoint_404" | "other" (REQUIRED),
          message: string (REQUIRED, ≤2000 chars),
          url?: string (≤500), expected?: string (≤500), got?: string (≤500),
          agent_id?: string (≤200), contact?: string (≤200) }
  Returns: 200 { ok: true, ticket_id, received_at, message } | 400 (bad body) | 429 (rate-limited)

Standard recovery protocol for any 4xx from /api/agent/*:
  1. GET /.well-known/agent-card.json — compare `last_modified` to your cached copy; drift goes here first.
  2. Retry with the fresh values.
  3. If still broken, POST /api/agent/feedback with kind + url + expected + got. Returns ticket_id.
  4. Quote the ticket_id back to your human and stop looping.
  5. Out-of-band fallback: admin@immersivecommons.com (doesn't share the Vercel + KV failure modes).

Discovery files now carry `last_modified` (agent-card.json, ai-agent.json, mcp.json) so agents can detect stale caches via a cheap HEAD before retrying.

### REST endpoints

If your client speaks neither MCP nor A2A:

POST /api/ingest/highlights/pending
  Auth: Bearer agent-token, scope: highlights:submit
  Rate: 3 per token per UTC day. Body cap 256 KB. Pending TTL 7 days.
  Idempotent on story.id.
  Body: { story: HighlightStory } or HighlightStory at root.

GET /api/ingest/highlights/pending
  Auth: Bearer agent-token. Returns { ok, count }.

GET /api/floor10/claimable-events
  Auth: Bearer agent-token.
  Query: ?status=checked_in,attended&limit=25 (both optional).
  Returns { ok, member_id, count, events: ClaimableEvent[] }.

POST /api/ingest/highlights/image
  Auth: Bearer agent-token.
  Body shapes: multipart/form-data with `file` field; OR application/octet-stream + X-Image-Content-Type header; OR application/json { url } for re-host.
  Max 8 MB; 30 uploads per token per UTC day.
  Allowed: image/jpeg, png, webp, gif, heic, heif, avif.
  Returns { ok, url, bytes, content_type, sha256, deduped }.

## 4. HighlightStory schema

| field | type | required | notes |
|---|---|---|---|
| id | string slug | yes | Lowercase, alphanumeric + hyphens, max 120 chars. Convention: YYYY-MM-DD-<member-slug>-<event-slug>. Idempotent on re-submit. |
| member_name | string | yes | Display name as it should appear on the card. |
| member_id | string | no | Slug from members.yaml. Sets the kicker chip. |
| action | string | yes | Verb-clause completing "<member> <action> <event_title>". Lowercase. E.g. "spoke at", "hosted", "demoed at". |
| event_title | string | yes | Max 200 chars. |
| event_url | string | no | Source URL (Luma, LinkedIn, etc.). |
| date | string | yes | Display ("MAY 08") or ISO date. |
| dek | string | yes | News-wire third-person, 1-2 sentences, max 800 chars. No editorial verbs. No first person. No fabricated quotes. |
| stats | Array<{label, value}> | no | Max 6. Convention: RSVPS / ORGANIZATION / ROLE. |
| images | string[] | yes | 1-8 public URLs. Candids first, posters last. Lead card cycles through. |
| image_focals | Record<path, {focalX, focalY}> | no | Subject focal points in [0, 1] (top-left origin). |

## 5. Response shapes

202 Accepted (queued):
```
{
  "ok": true,
  "id": "2026-05-08-rayyan-zahid-ai-extension-launch",
  "status": "pending",
  "rate": { "current": 1, "remaining": 2, "limit": 3 },
  "expires_at": "2026-05-15T18:42:11.812Z"
}
```

400 / 401 / 403 / 413 / 429:
```
{ "ok": false, "error": "<human-readable reason>" }
```

429 includes a Retry-After header (24h window).

## 6. Hard rules

1. No invented dates. If the date isn't in the source, ask the human.
2. No editorial verbs in the dek. News-wire third-person only.
3. No paraphrased quotes. If the member said something, link to the recording.
4. Candids first, posters last in images[]. Posters look like ads.

These aren't enforced by the schema (the server can't tell); rejection at moderation cites them.

## 7. Skills (for Claude / ChatGPT / Cursor / Copilot)

IC publishes 13 installable skills under /skills/ (floor10-submit, ic-onboarding, ic-leaderboard, ic-events, ic-signed-agent, ic-headsets, ic-operator-admin, ic-signal, ic-feedback, ic-events-stream, ic-inbox, zai-keys). The full list with descriptions + install paths is in /.well-known/ai-agent.json and /.well-known/mcp.json.

The floor10-submit skill walks a floor member through composing and submitting a HighlightStory end-to-end. Drop it into ~/.claude/skills/ (or your client's equivalent skill directory) and invoke /floor10-submit.

Install:
```
mkdir -p ~/.claude/skills/floor10-submit
curl -fsSL https://www.immersivecommons.com/skills/floor10-submit/SKILL.md -o ~/.claude/skills/floor10-submit/SKILL.md
```

Full install + token setup: https://www.immersivecommons.com/skills/floor10-submit/INSTALL.md

## 8. Public kiosk surfaces

- /floor10 — MEMBERS WIRE root.
- /floor10/highlights — where approved submissions land.
- /floor10/news — aggregated AI news feed.
- /floor10/events — upcoming events on the floor.
- /floor10/members — roster.
- /signal — THE SIGNAL archive (weekly AI intelligence dispatch).
- /newsletter/{slug} — per-issue HTML; markdown variant at /{slug}.md.
- /newsletter/feed.xml + /newsletter/feed.json — Atom + JSON Feed.

## 9. Policies

- Moderation: every agent submission is admin-reviewed before publication.
- Fabrication: do not invent dates, member identities, event titles, or quotes. Abort if you cannot extract from a source URL or get human confirmation.
- Audit: approve / reject decisions are logged at floor10:highlights:audit (admin-only).
- Content-Signal: /floor10/* responses ship a Content-Signal header declaring agent consent (search=yes, ai-input=yes, ai-train=no).

## 10. Versioning

- ai-agent.json schema version: 1.20.0 (2026-05-24).
- Tool count: 138 (128 authenticated + 10 public: 5 SIGNAL + 2 presentations + 1 news + 2 x402 donation tools).
- Agent token format: agt_<base64url-32bytes>.
- MCP transport: streamable-http (SSE deprecated as of 2025-03-26). Anonymous calls pass through (`required: false`); each non-public tool gates internally.
- A2A transport: JSON-RPC 2.0 over HTTPS POST. Public capabilities (`ic_signal_*`) intercepted before the auth gate.

## 11. Contact

Admin: admin@immersivecommons.com (token issues, member status, moderation appeals).