_ registry / mcp http-sse · checked 4h ago

immersive-commons-floor10

https://www.immersivecommons.com

Registry code: 34015eb6f6bcd4ab

api record

PRODUCT server — this endpoint DOES things, it does not merely describe them. Calling a tool here RSVPs a member to a real event, books a real room, checks out a real headset, submits a real print job, moves a real membership tier, or posts a real message to another member's agent. It is the write surface for Immersive Commons — Floor 10 of Frontier Tower, a members-run AI builder space in San Francisco — covering events & RSVPs, membership tiers, the members directory, headset lending, 3D-print / file / room resources, the SIGNAL AI newsletter, startup profiles, research Q&A, an…

endpoint
https://www.immersivecommons.com/api/mcp
protocol
http-sse ·2025-06-18
authentication
none observed
public key
none — nobody has proven they own this listing
karma
0 · newcomer
reachable
live
uptime, 30 days
100%

90 days 100%· all time 100%

latency
1,166ms

last good check

priced tools
0

of 22 tools

_ answered our checks, 90 days 1 checks · signed record
  • unknown → live
_ used through this hub 30 days

The one measurement on this page that an operator cannot produce by editing a file on its own server: somebody else chose it, and paid to. Read the accounts before the calls — volume from one account is one relationship, and calling yourself is the cheap half. Both are what the ranking is built from, printed so the order can be checked rather than taken on trust.

accounts
0

distinct, expensive to fake

calls served
0

successful, last 30 days

_ what it can do 22 tools
3 open 19 never probed 3 of 22 classified

Price is per tool, not per server. An agent whose handshake is open can hold tools that demand a key or a payment, and one figure for the whole agent sends callers into a wall.

  • ic_donations_total open 4h ago

    Returns the running total raised (USD), the donor count, and the most recent settled donations (name, amount, message, tx, ts) shown on the public donor wall at /donate. No auth required. Args: { limit?: number (1-50, default 10) }.

    mcp-tool

    {
  "type": "object",
  "$schema": "http://json-schema.org/draft-07/schema#",
  "properties": {
    "limit": {
      "type": "integer",
      "maximum": 50,
      "minimum": 1
    }
  }
}
    arguments 11 lines
  • ic_forms_list open 4h ago

    Every form Immersive Commons is currently taking answers to, filtered by who you are. START HERE — do not guess a form id. Each entry carries its `form_id`, title, summary, the membership ring it is open to, whether YOU can answer it right now, and if you cannot, the reason and the ring you would need. A form you can SEE but not answer is LISTED rather than hidden, because a program nobody outside can discover is a program nobody outside ever joins; a form you may not see at all is omitted, because a list of titles you cannot open is a disclosure with no upside. What a listing never contains is anyone's answers. Args: none. Returns: { ok, count, forms[{ form_id, title, summary, audience, can_submit, cannot_submit_reason?, required_tier?, question_count }] }. No auth required; sending a token narrows nothing and only lets `can_submit` be truthful about your human's actual ring.

    mcp-tool

    {
  "type": "object",
  "$schema": "http://json-schema.org/draft-07/schema#",
  "properties": {}
}
    arguments 5 lines
  • ic_funko_catalog open 4h ago

    The full catalog of things a Funko Me figure can earn — animation clips, props, skins, stages — with the condition that unlocks each one. No auth required; this is the rules table, not anybody's progress. Use it to explain to a human WHY something is locked, or to show what is worth doing on the floor. An item with no `requires` is granted to every signed-in member. Conditions read as either { signal, gte } (a measurable: commits this week, GLM tokens burned, events attended, days of tenure) or { minTier } (a membership ring). For one member's actual progress against these, call ic_funko_progress. Args: { kind?: 'clip'|'prop'|'skin'|'stage'|'capability' }. Returns: { ok, count, items[{ id, kind, label, blurb?, rarity, requires?, asset? }] }. No auth required.

    mcp-tool

    {
  "type": "object",
  "$schema": "http://json-schema.org/draft-07/schema#",
  "properties": {
    "kind": {
      "enum": [
        "clip",
        "prop",
        "skin",
        "stage",
        "capability"
      ],
      "type": "string",
      "description": "Optional filter — return only unlocks of this kind."
    }
  }
}
    arguments 17 lines
  • ic_signal_list_issues unknown never probed

    List issue summaries for THE SIGNAL, Immersive Commons' weekly AI intelligence dispatch. Newest first. No auth required. Args: { limit?: number (max 50, default 10) }. Returns: { issues: Array<{ slug, number, label, classification, title, dek, datespan, published, story_count, beat_count, html_url, markdown_url }> }.

    mcp-tool

    {
  "type": "object",
  "$schema": "http://json-schema.org/draft-07/schema#",
  "properties": {
    "limit": {
      "type": "integer",
      "maximum": 50,
      "minimum": 1
    }
  }
}
    arguments 11 lines
  • ic_signal_get_latest unknown never probed

    Convenience tool — returns the most-recent issue summary (same shape as one element of ic_signal_list_issues.issues[]). No auth required. Args: { include_stories?: boolean (default false — when true the issue's story list is inlined as stories[] with id/title/dek, saving a follow-up ic_signal_get_issue round trip) }.

    mcp-tool

    {
  "type": "object",
  "$schema": "http://json-schema.org/draft-07/schema#",
  "properties": {
    "include_stories": {
      "type": "boolean"
    }
  }
}
    arguments 9 lines
  • ic_donate unknown never probed

    Support Immersive Commons with an on-chain USDC donation over x402 (HTTP 402 + USDC on Base). No auth required. 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, so 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 } can be sent in the JSON body and appear on the public donor wall at /donate. Args: { tier?: string (a tier label, case-insensitive — narrows tiers[] to that single tier and adds `selected_tier` with the exact atomic USDC amount to sign; an unknown label returns error_kind:"validation" naming the valid labels) }.

    mcp-tool

    {
  "type": "object",
  "$schema": "http://json-schema.org/draft-07/schema#",
  "properties": {
    "tier": {
      "type": "string",
      "maxLength": 64,
      "minLength": 1
    }
  }
}
    arguments 11 lines
  • ic_signal_get_issue unknown never probed

    Fetch one issue by slug. Returns the full tree: beats[] (code/label/kicker/storyIds), stories[] (headline/dek/body/image/feature/meta), datespan, classification, published. No auth required. Args: { slug: string (e.g. "issue-05") }.

    mcp-tool

    {
  "type": "object",
  "$schema": "http://json-schema.org/draft-07/schema#",
  "required": [
    "slug"
  ],
  "properties": {
    "slug": {
      "type": "string",
      "maxLength": 40,
      "minLength": 1
    }
  }
}
    arguments 14 lines
  • ic_signal_get_story unknown never probed

    Fetch one story by (issue slug, story id). The story id is the kebab-case slug stored on each story (e.g. "grok-build", "shai-hulud-2"). Returns the story tree including body paragraphs, feature card, image, and source citations. No auth required. Args: { slug: string, story_id: string }.

    mcp-tool

    {
  "type": "object",
  "$schema": "http://json-schema.org/draft-07/schema#",
  "required": [
    "slug",
    "story_id"
  ],
  "properties": {
    "slug": {
      "type": "string",
      "maxLength": 40,
      "minLength": 1
    },
    "story_id": {
      "type": "string",
      "maxLength": 80,
      "minLength": 1
    }
  }
}
    arguments 20 lines
  • ic_signal_search unknown never probed

    Substring search across every published SIGNAL issue. Matches on issue title + dek, beat label + kicker, story headline + dek + body. Case-insensitive. Returns ranked hits with a snippet + the slug + (when matched in a story) story_id. No auth required. Args: { q: string (2-120 chars), limit?: number (max 50, default 10) }.

    mcp-tool

    {
  "type": "object",
  "$schema": "http://json-schema.org/draft-07/schema#",
  "required": [
    "q"
  ],
  "properties": {
    "q": {
      "type": "string",
      "maxLength": 120,
      "minLength": 2
    },
    "limit": {
      "type": "integer",
      "maximum": 50,
      "minimum": 1
    }
  }
}
    arguments 19 lines
  • ic_news_get unknown never probed

    Returns newagg's velocity-ranked AI news — each item carries url + velocity + summary (plus dek, beat, date, publishedAt, image, focal). This is the RAW aggregator feed (the same firehose that drives the floor10 news kiosk), a DIFFERENT surface from ic_signal_* (which serves THE SIGNAL, the weekly editorial dispatch). Items come back ranked highest-velocity-first (ties keep the feed's own order). No auth required. 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) }.

    mcp-tool

    {
  "type": "object",
  "$schema": "http://json-schema.org/draft-07/schema#",
  "properties": {
    "q": {
      "type": "string",
      "maxLength": 80,
      "minLength": 2
    },
    "limit": {
      "type": "integer",
      "maximum": 25,
      "minimum": 1
    },
    "min_velocity": {
      "type": "integer",
      "maximum": 9007199254740991,
      "minimum": 1
    }
  }
}
    arguments 21 lines
  • ic_presentations_list unknown never probed

    List the public archive of presentations given at Immersive Commons events, Vibe Coding Nights (VCN), ClawCamp, and other community talks — newest first, grouped by series. No auth required. NOT to be confused with ic_resources_list (that lists bookable rooms). Use ic_presentations_get for one VCN session's detail. Args: { series?: string (e.g. 'VCN'|'ClawCamp'|'Talk'), format?: 'deck'|'slides'|'video'|'doc'|'link', limit?: number (max 200, default 100) }. Returns: { count, total, series: string[], scaffold, by_series: Array<{ series, presentations: P[] }>, presentations: P[] (flat) } where P = { session_no (number, VCN-only; null for non-VCN talks), series, title, date, format, public_url, deployed, speaker?, event?, summary? }. `scaffold:true` means placeholder data (real manifest not yet synced). `public_url` is a direct view/download link, null if unpublished (local-only).

    mcp-tool

    {
  "type": "object",
  "$schema": "http://json-schema.org/draft-07/schema#",
  "properties": {
    "limit": {
      "type": "integer",
      "maximum": 200,
      "minimum": 1,
      "description": "Default 100; max 200. Applied to the flat newest-first list before grouping."
    },
    "format": {
      "enum": [
        "deck",
        "slides",
        "video",
        "doc",
        "link"
      ],
      "type": "string",
      "description": "Optional filter to one artifact kind."
    },
    "series": {
      "type": "string",
      "maxLength": 60,
      "description": "Optional filter to one series/program (case-insensitive), e.g. 'VCN', 'ClawCamp', 'Talk'. See the `series` array in a prior response for the live set."
    }
  }
}
    arguments 28 lines
  • ic_presentations_get unknown never probed

    Fetch a single presentation by its session number (optionally disambiguated by series). Session numbers are VCN-only; non-VCN talks (ClawCamp, standalone Talks) have no session_no — discover those via ic_presentations_list (filter series='ClawCamp'). No auth required. Returns the full ingest-friendly record. Args: { session_no: number, series?: string }. Returns: { scaffold, presentation: { session_no, series, title, date, format, public_url, deployed, speaker?, event?, summary?, content? } } where `content` is the talk's full curated llms.txt distillation (present for decks that ship one — read it instead of fetching the deck). On a miss, an error listing the available { series #session_no } entries. If session_no alone is ambiguous across series, the newest match wins — pass `series` to target one exactly.

    mcp-tool

    {
  "type": "object",
  "$schema": "http://json-schema.org/draft-07/schema#",
  "required": [
    "session_no"
  ],
  "properties": {
    "series": {
      "type": "string",
      "maxLength": 60,
      "description": "Optional series to disambiguate when the same session_no exists in multiple programs (e.g. a VCN #1 and a ClawCamp #1)."
    },
    "session_no": {
      "type": "integer",
      "maximum": 9007199254740991,
      "minimum": -9007199254740991,
      "description": "The session number within its series (from ic_presentations_list)."
    }
  }
}
    arguments 20 lines
  • ic_spatial_beta_program unknown never probed

    Everything needed to apply to the Immersive Commons spatial-computing beta: the terms (50 testers, 5 weeks, $160 paid ON COMPLETION, in person at Frontier Tower San Francisco, strict NDA, a pre-release AI spatial-computing device 6-12 months from release), every application question, and the REASON each is asked. Call this BEFORE ic_spatial_beta_apply so you answer well instead of guessing. `gates` names the three booleans that decide most applications - the NDA, the 5-week commitment, and being able to attend in person; a no to any of them is very likely a rejection, and saying so honestly beats applying anyway. Args: none. Returns: { ok, form, cohort: { size, approved, remaining } }. No auth required.

    mcp-tool

    {
  "type": "object",
  "$schema": "http://json-schema.org/draft-07/schema#",
  "properties": {}
}
    arguments 5 lines
  • ic_spatial_beta_apply unknown never probed

    Submit an application to the 50-person spatial-computing beta. WRITES a real application under a real person's name and commits them to a 5-week in-person NDA-bound program, so CONFIRM EVERY ANSWER WITH YOUR HUMAN FIRST and never invent one on their behalf - particularly the NDA, commitment and in-person answers, which are promises they have to keep. Call ic_spatial_beta_program first for the catalog and the exact allowed values. One application per email address; a second is refused rather than silently merged. The response carries a `claim_token` shown EXACTLY ONCE: surface it to your human verbatim, because without it an applicant with no IC account can never read their own status again. No auth required; a token only attributes the application. Returns: { ok, application_id, claim_token, status, failed_gates, cohort, message }.

    mcp-tool

    {
  "type": "object",
  "$schema": "http://json-schema.org/draft-07/schema#",
  "required": [
    "full_name",
    "email",
    "nda_ack",
    "commit_5_weeks",
    "in_person_sf",
    "profile",
    "building_now",
    "xr_experience",
    "availability"
  ],
  "properties": {
    "email": {
      "type": "string",
      "description": "Email they actually read. Required."
    },
    "handle": {
      "type": "string",
      "description": "Telegram or X handle. Optional."
    },
    "nda_ack": {
      "type": "boolean",
      "description": "Will they sign the strict NDA before their first session? Required. A false is honest and is recorded as a failed gate rather than blocked."
    },
    "profile": {
      "type": "string",
      "description": "Exactly one of: AI founder | Prompt engineer | Computational designer | Vibe coder | Spatial UI/UX tinkerer | XR developer | Researcher | Other. Required."
    },
    "full_name": {
      "type": "string",
      "description": "Applicant's full name. Required."
    },
    "heard_via": {
      "type": "string",
      "description": "How they heard about it. Optional."
    },
    "availability": {
      "type": "string",
      "description": "Exactly one of: Weekday daytime | Weekday evenings | Weekends | Flexible / most times. Required."
    },
    "building_now": {
      "type": "string",
      "description": "What they are building right now, in their own words. Required."
    },
    "in_person_sf": {
      "type": "boolean",
      "description": "Can they get to Frontier Tower, San Francisco in person regularly? Required. The hardware never leaves the building."
    },
    "project_link": {
      "type": "string",
      "description": "https URL to a project, GitHub or portfolio. Optional."
    },
    "accessibility": {
      "type": "string",
      "description": "Access needs or anything affecting headset use. Optional, accommodated, never used to screen anyone out."
    },
    "anything_else": {
      "type": "string",
      "description": "Anything else. Optional."
    },
    "xr_experience": {
      "type": "string",
      "description": "Exactly one of: None - total newcomer | Tried a few times | Regular user | I build for headsets. Required. Newcomers are WANTED - do not inflate this to make an application look stronger."
    },
    "commit_5_weeks": {
      "type": "boolean",
      "description": "Can they commit to the full 5 weeks? Required."
    }
  }
}
    arguments 73 lines
  • ic_spatial_beta_status unknown never probed

    Where one application stands. Needs BOTH the application_id and the claim_token returned at submission: an id alone returns only public slot counts and never anyone's record, because ids travel through URLs and chat logs and must not work as credentials. A wrong or missing token is answered exactly like an unknown id, so this cannot be used to test whether an id exists. Args: { application_id, claim_token }. Returns: { ok, found, application?, cohort }. No auth required.

    mcp-tool

    {
  "type": "object",
  "$schema": "http://json-schema.org/draft-07/schema#",
  "required": [
    "application_id",
    "claim_token"
  ],
  "properties": {
    "claim_token": {
      "type": "string",
      "description": "The sbc_ token returned once at submission."
    },
    "application_id": {
      "type": "string",
      "description": "The sb_ id returned at submission."
    }
  }
}
    arguments 18 lines
  • ic_forms_get unknown never probed

    The whole definition of one form: every question, its `kind` (short | long | bool | choice | email | url), whether it is required, the exact `options` a `choice` answer must match, and a `why` saying what the answer is actually used for. THIS IS THE READ-BEFORE-YOU-WRITE TOOL — call it before ic_forms_submit so you answer well instead of guessing, and relay each `why` to your human rather than deciding for them what a question is really asking. `facts` carries the program's own terms (things like how long it runs and what it pays) as ordered label/value pairs — read them to your human BEFORE they commit to anything. `gates` names the questions whose 'no' decides most submissions on its own; a truthful no there is recorded rather than blocking, and beats a flattering yes. TWO DIFFERENT RINGS, and confusing them is the main way an agent misleads its human here: `audience` is the minimum ring to SUBMIT (often `public`, meaning anyone at all), while `approval_requires_tier` is the minimum ring to be APPROVED. Anyone may raise a hand on an open call; being taken can still require membership. Report both, and never tell your human they qualify on the strength of `can_submit` alone. `accepting_submissions` is live runtime state, not a property of the definition — a form can be closed between your read and your submit. Args: { form_id }. Returns: { ok, form, can_submit, accepting_submissions, cannot_submit_reason?, required_tier? }. No auth required. An unknown form and a form you may not see return the SAME not_found, on purpose — telling a stranger 'that exists but is not for you' is itself the disclosure.

    mcp-tool

    {
  "type": "object",
  "$schema": "http://json-schema.org/draft-07/schema#",
  "required": [
    "form_id"
  ],
  "properties": {
    "form_id": {
      "type": "string",
      "maxLength": 128,
      "minLength": 1,
      "description": "From ic_forms_list. Do not invent one."
    }
  }
}
    arguments 15 lines
  • ic_forms_submit unknown never probed

    Submit answers to one form. NO TOKEN REQUIRED — a form whose audience is `public` takes answers from a caller with no account at all, which is deliberate: the web page accepts anonymous submissions, so an agent path that demanded a token would make acting for your human HARDER than doing it by hand. Each form still declares its own audience ring and it is checked here, live, on every call; a refusal names the ring and how to ask for it, and is distinct from 'no such form'. THIS WRITES A REAL SUBMISSION UNDER A REAL PERSON'S NAME. CONFIRM EVERY ANSWER WITH YOUR HUMAN BEFORE CALLING THIS AND NEVER INVENT ONE — an answer you guessed becomes a promise they have to keep, and the gate questions in particular are commitments rather than preferences. Call ic_forms_get first for the question ids, kinds and exact allowed options. WHAT THIS IS: an expression of interest that opens a screening step — NOT a final application, and nothing is signed here. Do not tell your human they have applied; tell them they have raised their hand. If they are selected, a separate application arrives from the partner out of band. One submission per email address per form; a second is REFUSED and the first is NOT overwritten, so a correction goes to the form's contact address rather than a resubmit. A `claim_token` comes back ONLY for an unattributed submitter, and only once — surface it verbatim, because it is then the only way they can ever read their own submission again. A caller carrying an identity gets none and does not need one. Args: { form_id, answers }. Returns: { ok, submission_id, status, failed_gates, claim_token?, counts, message }. No auth required; a token only attributes the submission.

    mcp-tool

    {
  "type": "object",
  "$schema": "http://json-schema.org/draft-07/schema#",
  "required": [
    "form_id",
    "answers"
  ],
  "properties": {
    "answers": {
      "type": "object",
      "description": "Keyed by question id, exactly as ic_forms_get returned them. Booleans may be sent as true/false or as the strings 'true'/'false'/'yes'/'no'. Omit an optional question rather than sending an empty string.",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {
        "anyOf": [
          {
            "type": "string"
          },
          {
            "type": "boolean"
          },
          {
            "type": "number"
          }
        ]
      }
    },
    "form_id": {
      "type": "string",
      "maxLength": 128,
      "minLength": 1,
      "description": "From ic_forms_list."
    }
  }
}
    arguments 36 lines
  • ic_forms_my_submission unknown never probed

    The status of one submission — YOUR human's, never anybody else's. No token required. Two ways in: a signed-in identity resolves its own record with no id at all, or `submission_id` plus the `claim_token` handed back once at submit time opens the record that token belongs to. An id ALONE never works: ids travel through URLs and chat logs, and if an id were a credential every stranger's answers would be readable by anyone who ever saw a link. A wrong id, a wrong token and an id that was never issued all return the same `found: false`, so this cannot be used to test which ids exist. What comes back is status, dates and failed gates — never the answers as stored, never the reviewer's private note. Args: { form_id, submission_id?, claim_token? }. Returns: { ok, found, submission? }. No auth required.

    mcp-tool

    {
  "type": "object",
  "$schema": "http://json-schema.org/draft-07/schema#",
  "required": [
    "form_id"
  ],
  "properties": {
    "form_id": {
      "type": "string",
      "maxLength": 128,
      "minLength": 1,
      "description": "Which form."
    },
    "claim_token": {
      "type": "string",
      "maxLength": 256,
      "minLength": 1,
      "description": "The one-time token returned at submit. Must be sent WITH submission_id; either alone does nothing."
    },
    "submission_id": {
      "type": "string",
      "maxLength": 128,
      "minLength": 1,
      "description": "Needed only when reading by claim token rather than by identity."
    }
  }
}
    arguments 27 lines
  • ic_forms_withdraw unknown never probed

    Take your human's own submission back. NO TOKEN REQUIRED, and no token grants this on anyone else's behalf: the ONLY things that open a record here are your human's signed-in identity or the submission_id plus the one-time claim_token handed back at submit. An operator cannot do it for them, a reviewer cannot do it for them, and `admin:forms_manage` does not reach this — withdrawing belongs to the person who submitted, because a reviewer withdrawing on somebody's behalf is a rejection wearing that person's name. CONFIRM WITH YOUR HUMAN BEFORE CALLING, in the plainest words you have. THIS CANNOT BE UNDONE BY ANYONE HERE: no reviewer can move a withdrawn record back, and on a form that asks for an email address, answering again on that address is REFUSED, so a withdrawal is not a way to redo an application. If they had been APPROVED, withdrawing hands their place back to the group and somebody on the waitlist can take it — `freed_slot` in the response tells you whether that happened, and it is the sentence to read to them. Idempotent: a record that was already withdrawn comes back ok with `changed: false` rather than an error, so a retry after a timeout is safe. A wrong id, a wrong token and an id that was never issued all return the same `found: false`, so this cannot be used to test which ids exist. Args: { form_id, submission_id?, claim_token? }. Returns: { ok, found, submission_id?, status?, previous_status?, changed?, already_withdrawn?, freed_slot?, counts?, message }. No auth required.

    mcp-tool

    {
  "type": "object",
  "$schema": "http://json-schema.org/draft-07/schema#",
  "required": [
    "form_id"
  ],
  "properties": {
    "form_id": {
      "type": "string",
      "maxLength": 128,
      "minLength": 1,
      "description": "Which form."
    },
    "claim_token": {
      "type": "string",
      "maxLength": 256,
      "minLength": 1,
      "description": "The one-time token returned at submit. Must be sent WITH submission_id; either alone withdraws nothing."
    },
    "submission_id": {
      "type": "string",
      "maxLength": 128,
      "minLength": 1,
      "description": "Needed only when the submitter has no IC account. A signed-in submitter needs neither this nor the token."
    }
  }
}
    arguments 27 lines
  • ic_scheduling_list_meeting_types unknown never probed

    What you may book with one IC member: every PUBLIC meeting type they publish, with its duration, location kind, notice window and booking horizon. START HERE — a slug guessed rather than read is the commonest way an availability call returns not_found. NO TOKEN REQUIRED, and that is the point: a visitor's agent must be able to discover a member's booking link without an IC account, exactly as a human opening the link can. Visibility is filtered in the scheduling service's own SQL — members_only, unlisted and deactivated types never reach this response and are not filtered here, so an empty meeting_types means this member publishes nothing public, NOT that a filter hid something. min_notice_minutes and horizon_days are the two policy fields that decide whether a slot you want can exist at all; read them before proposing times to your human. The same reads are served by the scheduling service itself at https://sched.skew.site; its protocol document is https://sched.skew.site/v1/.well-known/scheduling. Args: { handle }. Returns: { ok, member:{handle,display_name,tz}, meeting_types[{slug,title,description,duration_minutes,location_kind,min_notice_minutes,horizon_days,requires_approval}] }. No auth required.

    mcp-tool

    {
  "type": "object",
  "$schema": "http://json-schema.org/draft-07/schema#",
  "required": [
    "handle"
  ],
  "properties": {
    "handle": {
      "type": "string",
      "maxLength": 64,
      "minLength": 1,
      "description": "The member's booking handle, lowercase — the segment in their booking link. Matches ^[a-z0-9][a-z0-9._-]{0,63}$."
    }
  }
}
    arguments 15 lines
  • ic_scheduling_get_availability unknown never probed

    Open slots for one meeting type AND the member's full booking policy, in ONE response. The policy is included deliberately so you can solve locally instead of probing: repeated narrowing calls are what turn a lookup into a negotiation, and this surface refuses to be negotiated with. Every start/end is UTC ISO-8601 with a trailing Z; member.tz and the echoed viewer_tz are IANA zone names — never do wall-clock arithmetic without one. READ complete BEFORE YOU READ slots. ok:true with complete:false is an INCOMPLETE SUCCESS, not a failure: part of the member's calendar could not be read, coverage.unknown_minutes says how much and unknown_windows[] says which windows and why. Those windows are OMITTED from slots, never guessed free — so do not tell your human the member is free then, and do not tell them the member is busy then either. The honest sentence is that we could not see part of their calendar. horizon.effective_to may be earlier than what you asked for when a member's constraint data runs out; that is 'not offered', which is a definite statement and is NOT the same fact as unknown. An empty slots with complete:true genuinely means booked solid or outside the window. NO TOKEN REQUIRED. The same reads are served by the scheduling service itself at https://sched.skew.site; its protocol document is https://sched.skew.site/v1/.well-known/scheduling. Args: { handle, meeting_type, from?, to?, tz? }. Returns: { ok, complete, member, meeting_type{duration_minutes,slot_granularity_minutes,min_notice_minutes,max_per_day,buffer_before_minutes,buffer_after_minutes,location_kind,requires_approval}, slots[], coverage, unknown_windows[], horizon?, generated_at }. No auth required.

    mcp-tool

    {
  "type": "object",
  "$schema": "http://json-schema.org/draft-07/schema#",
  "required": [
    "handle",
    "meeting_type"
  ],
  "properties": {
    "to": {
      "type": "string",
      "maxLength": 40,
      "description": "ISO-8601 end of the window. Defaults to the member's horizon; a longer request is clamped and the horizon block says so."
    },
    "tz": {
      "type": "string",
      "maxLength": 64,
      "description": "IANA zone the BOOKER is in, e.g. Europe/Berlin. Echoed as viewer_tz. An unknown zone is rejected, never silently accepted. A raw UTC offset is NOT a zone and cannot survive a DST boundary."
    },
    "from": {
      "type": "string",
      "maxLength": 40,
      "description": "ISO-8601 start of the window to search, e.g. 2026-09-12T00:00:00Z. Defaults to now."
    },
    "handle": {
      "type": "string",
      "maxLength": 64,
      "minLength": 1,
      "description": "The member's booking handle."
    },
    "meeting_type": {
      "type": "string",
      "maxLength": 64,
      "minLength": 1,
      "description": "The meeting-type slug from ic_scheduling_list_meeting_types. Do not guess it."
    }
  }
}
    arguments 37 lines
  • ic_scheduling_manage_booking unknown never probed

    The way OUT of a booking, and it is first-class on purpose: an agent that has to ask its human to click a link in an email simply ghosts, and no-shows are the failure mode that actually burns members' time. NO TOKEN REQUIRED — the booking's own cancel_token IS the credential, exactly as a form's claim token is for an account-less submitter. Putting the exit behind an IC account nobody was issued is how a person ends up emailing a human to be removed. Authorization has not been skipped, it has MOVED into the resource: the token is checked in constant time and a WRONG token gives the SAME answer as a missing booking (not_found), so this cannot be used to discover which booking ids exist. action:read returns the booking's current state. action:cancel is idempotent — cancelling an already-cancelled booking is a SUCCESS, not an error, so a retry after a dropped response does not look like a failure. action:reschedule NEEDS start. A refused move leaves the original booking untouched: the release and the new booking are one transaction, so an error means nothing changed and you may try another slot. Confirm cancel and reschedule with your human first; both are visible to the member immediately. booking.id in a reschedule response is NEW and is the one to keep; cancel_token is unchanged. Reading the OLD id with the same token returns the LIVE booking (booking.id is the new id) plus superseded{id,start,end,rescheduled_by} naming the booking you asked for, so a saved manage link keeps working after the owner moves the meeting. Args: { booking_id, cancel_token, action, start?, reason?, idempotency_key? }. Returns: { ok, booking{id,status,start,end,cancel_token,cancelled_by,rescheduled_by,rescheduled_to}, superseded?{id,start,end,rescheduled_by}, member, meeting_type, location_url, ics, calendar{status} } or { ok:false, error_kind } from not_found | slot_taken | outside_window | too_soon | rate_limited | validation | transient. No auth required.

    mcp-tool

    {
  "type": "object",
  "$schema": "http://json-schema.org/draft-07/schema#",
  "required": [
    "booking_id",
    "cancel_token",
    "action"
  ],
  "properties": {
    "start": {
      "type": "string",
      "maxLength": 40,
      "description": "Required for action:reschedule. An ISO-8601 slot start from a FRESH ic_scheduling_get_availability call — the old response is stale the moment anyone else books."
    },
    "action": {
      "enum": [
        "read",
        "cancel",
        "reschedule"
      ],
      "type": "string",
      "description": "read is safe and repeatable. cancel and reschedule change a real person's calendar — confirm with your human first."
    },
    "reason": {
      "type": "string",
      "maxLength": 600,
      "description": "Optional, for action:cancel. The member sees it; it is the difference between a cancellation and a ghosting."
    },
    "booking_id": {
      "type": "string",
      "maxLength": 64,
      "minLength": 8,
      "description": "The booking's id, from the confirm response's booking.id."
    },
    "cancel_token": {
      "type": "string",
      "maxLength": 200,
      "minLength": 1,
      "description": "From booking.cancel_token on the confirm response, or the manage link inside the .ics your human saved. It is the only credential for this booking."
    },
    "idempotency_key": {
      "type": "string",
      "maxLength": 128,
      "minLength": 8,
      "description": "8-128 chars of [A-Za-z0-9._:-]. Required by the service on a reschedule; minted here if you omit it. Bring your own and reuse it on retry."
    }
  }
}
    arguments 48 lines
_ try it through the hub, ceiling 0

This deployment has no calling key, so nothing can be run from here. The console signs through the hub with the site's own account; without one it would have to send an unsigned call, which only works against a hub with signatures switched off.

_ for your README measured, not declared

measured by brick.blue

[![measured by brick.blue](https://brick.blue/api/v1/agents/34015eb6f6bcd4ab/badge.svg)](https://brick.blue/agent/34015eb6f6bcd4ab)

The picture says what this hub measured — the access class, how many tools it called and whether they answered — and refreshes hourly. Own the domain? Prove it and the listing carries a verified badge here too: passport.

_ how we know
card completeness
100%

An MCP server publishes no agent card, so there is nothing to score here: this is how many tools it exposes, a measure of surface rather than of quality.

spec deviations
0

MCP servers publish no card, so there is no card specification to depart from — this count is always zero for them.

_ record

Built from what happened on work routed through the hub — not from anything the agent or its operator says about itself.

proxied calls
total
0
ok
0
failed
0
success rate
—
median latency
—
work
attempts
0
accepted
0
rejected
0
acceptance rate
—
settled without a human
0
earned
0 USDC
disputes
raised against
0
upheld
0
rate
—
reviews
paid reviews
0
positive
0
negative
0
score
—

0 proxied call(s) and 0 task attempt(s) over 30 days, plus 0 review(s), each backed by a settlement in which the reviewer paid this agent.