add_applet
ChatGPTSave an HTML page you made (a mockup, chart, prototype or report) as an applet: people see and use it live inside a note. It follows the same rules as a claude.ai Artifact, so an Artifact's HTML works here as is: one self-contained page, with or without the <!doctype>/<html> shell. Scripts inline or from cdnjs.cloudflare.com, cdn.jsdelivr.net/npm/, cdn.tailwindcss.com or code.jquery.com (pin exact versions); stylesheets inline or from Google Fonts; media and fonts as data: URIs. For images, upload each with upload_image and use the URL it returns, or the URL of an image already in a note you can read (in <img>, CSS or JS): everyone who can read the note sees them, and nobody else. No fetch or other requests, no other sites in iframes, no popups or new windows, and alert/confirm/print do nothing, so build those into the page. Sound starts only from a click. There is no Artifact runtime: window.claude.use(...) resolves null for every capability, so nothing a viewer does is saved; write pages that work without it. Up to 3 MB. It returns markdown: place it in the note's content (create_note, edit_note, append_to_note) where the applet belongs, usually as the only thing in a collapsible section titled with what the applet is, e.g. :::details / :::detailsSummary / <title> / ::: / :::detailsContent / <the markdown> / ::: / :::. Pick its size, a fixed height in the note: "compact" (240px) for a small, focused idea, or "tall" (600px) when it needs the room. Its height is the same at every width, and its width is the note's text column, from 343px on a phone to about 690px on a laptop, so build for the narrow width first: wrap or stack rather than cut text off, and don't rely on scrolling inside it. The idea has to fit that size; anything bigger belongs in Expanded, where the reader opens the applet over the note and the same page gets the extra room. To update an applet you made, pass replace with its URL: every note it's in shows the change at once, even where it's open, no note edit needed. Only the user can open it until you place it: then everyone who can read that note can.
add_components
ChatGPTWrite a note's components as Markdown (ui_spec from create_note, or get_ui_spec, has the syntax). Readers watch each call land in place of the loading placeholders. Each call adds its top-level blocks to the end of the note in order, or under parent (and slot, for Tabs) and after a sibling. Set complete: true on your last call; id and complete: true alone also finishes. On a note that has text, the text is a Markdown block (id "text") inside the page Stack (id "page"); add yours before or after it, and change the text itself with edit_note. If any block is invalid nothing is added and the error says which line and why: fix that and send the call again.
append_to_note
ChatGPTAdd markdown to the end of a note, without touching what's already there. Works on any note the user can edit, not only their own. Set source to say whose thinking it is, or pass segments when it mixes theirs and yours.
cancel_invitations
ChatGPTCancel pending invitations to a team workspace (ids from get_workspace), so their links stop working. Admins only.
create_note
ChatGPTMaking a note: call this FIRST, immediately, with only components (the names you'll use, in reading order, repeats included) and a short title. No content, and nothing else first. It creates a private draft the reader sees right away, with loading placeholders, and returns note.id and ui_spec, the Markdown syntax for those components. Then write it with add_components, complete: true on the last call. Call create_note once per note. For direct creation without a component plan, send a short title and the content, written for a person. Set primary to say whose thinking the content is; prefer writing down your person's own words and thinking over your version of it. Share it with recipient_ids from list_members, or with emails for anyone else. Omit both for a personal note only the author can see. The note is created first, then shared: if sharing needs the user's OK, the result says the note is private for now and sharing.needs_confirmation has the details; if sharing fails, sharing.error says why. Either way, use share_note next, not create_note again.
create_workspace
ChatGPTCreate a team workspace, with the user as its admin. Invite people with invite_to_workspace. Only when the user asks for one.
edit_applet
ChatGPTChange part of an applet you made: replaces old_text with new_text in its HTML, and every note it's in shows the change at once. Copy old_text exactly from get_applet; it must match exactly one place. new_text can be empty to delete. For a full rewrite, use add_applet with replace.
edit_note
ChatGPTChange part of a note: replaces old_text with new_text. Works on any note the user can edit, not only their own. Copy old_text exactly from the note's current markdown (call get_note first). It must match exactly one place, so include enough surrounding text. new_text can be empty to delete. If the note changed since you read it, you get an error: re-read it and retry. Set source to say whose thinking new_text is, or pass segments when it mixes theirs and yours. The author can also change the title; pass it on its own or with a text change.
get_applet
ChatGPTRead the HTML of an applet in a note (its /api/applets/... URL, as in the note's :::applet line), to see what it shows or to change it with edit_applet. Works for any applet the user can open.
get_image
ChatGPTLook at one image from a note or its chat at full size (up to 1600px wide), to read small text or see detail the thumbnails in get_note don't show. Pass the image's file name (like 3f2a…c9.png), its URL, or its markdown. It also returns download_url, a link to the original file that works for an hour without signing in, for saving it or passing it to another tool. Only images the user can open.
get_invite_link
ChatGPTA team workspace's invite link, with how many people joined through it and whether it expired: anyone signed in who has it can join. Null when there isn't one. Admins only.
get_note
ChatGPTRead one note: its title, workspace, author (and agent, when an agent made it), recipients, and its full text as markdown. comments is the note's chat as people see it: one stream of messages, oldest first, each with an id (pass it to add_comment as reply_to to answer it), a url linking straight to it, its author, reply_to (the id of the message it answers, or null), quote (the passage of the note it's about, or null), applet (on a message about an applet, that applet's src, written while it was expanded), its markdown, and how many thumbs-ups it has. agent is set on messages an agent wrote for its person, and primary says whose thinking it was: the person's ("user") or the agent's own ("agent"). Pass a message's link as id (or its id as message_id) and the result also has message: the message the user opened, which is what they want to work on. For the note's author, access_requests lists people asking to open it (approve or decline with share_note). A note the user can't open answers no_access. With authorship, the result also has authorship: the note's text in order, in spans by who wrote them ("Kyle", "Kyle via Claude", "Kyle's agent", "Kyle with Claude" for an agent's writing that didn't say whose thinking it was, or unknown when nothing recorded it), as the app's "Show who wrote what" shows it.
get_note_components
ChatGPTA components note's outline: one line per component, indented under its parent. Pass components to get their current Markdown properties and child/slot IDs before replacing their properties with patch_component(markdown).
get_profile
ChatGPTThe signed-in user's Jetpost account: id and name.
get_ui_spec
ChatGPTThe Markdown syntax, rules and an example for components create_note's ui_spec didn't cover, or for editing an existing note. Pass names to get just those. For Image and MediaHeader, assetId is the full uploaded filename from upload_image's URL, including its extension (e.g. uuid.jpg); upload the bytes before placing it. For Applet, appletId is the id in add_applet's url (/api/applets/<id>.html); the url works too.
get_workspace
ChatGPTA workspace's details: the user's role and member count, and for admins its members, pending invitations (with ids), the invite link and former_member_notes (shared notes whose author left).
invite_to_workspace
ChatGPTInvite people to a team workspace by email (each gets an invitation to accept), and get, reset or turn off its invite link: anyone signed in who has the link can join. Admins only. Joining a team lets people see its members and every note opened to everyone there, never anyone's private notes.
join_workspace
ChatGPTJoin a team workspace with an invite link (…/join/…) or an email invitation's link (…/invite/…), as the user. Only when the user asks you to.
leave_workspace
ChatGPTTake the user out of a team workspace. They lose its notes, including their own, and need a new invitation to come back.
list_activity
ChatGPTWhat happened recently across the notes the user can read in one workspace, newest first: edits (with who made them, a word diff, [-removed-] {+added+}, and a one-line summary when its agent described it, else null), new notes, notes shared with the user or opened to the workspace or the link, chat messages (with message_id, and quote when one quotes a passage of the note), thumbs-ups, and requests to open the user's notes (access_requested, with the request's id for share_note's approve_request_ids or decline_request_ids). The user's own activity is included. Use it to answer "what changed since I last looked?" or to decide what's worth raising with the user. Reading it doesn't mark anything seen for the user. Pass since to get only newer events: "last_looked" for everything since the user last had Jetpost open in that workspace (to catch them up), or a time. Pass before (from next_before) for older ones. The result includes last_looked_at, when the user last had Jetpost open in that workspace. Pass notifications: true for only what was addressed to the user by someone else: notes shared with them, messages on their notes (ones they wrote, are on, or wrote in the chat of), replies to their messages, thumbs-ups on them, edits to notes they're on, and pending requests to open their notes, each with unread.
list_changes
ChatGPTA note's history, newest first: each edit with who made it (a person or their agent), a word diff ([-removed-] {+added+}) and a one-line summary when its agent described it (else null), back to when it was created. Use it when the user asks what changed in a note or who changed it. Pass before (from next_before) for older changes. Pass summarize for one sentence on what the returned edits did together.
list_members
ChatGPTList the people the user can share with in a workspace: the user, everyone in it (inside: true), and people they've shared notes with there. Their ids work as recipient_ids. party is who they count as for sharing outside the workspace: their company's domain, or "personal" for a personal address (each is its own party). ambiguous_name: true means someone else in the list has the same name; it comes with their email so you can ask the user which one. Pass id (a note) to list people for that note's workspace. Share with anyone else by email address.
list_messages_for_you
ChatGPTMessages in Jetpost notes' chats that are waiting for you (this agent): ones that @mention you or reply to one of your messages, from people or other agents, that you haven't answered yet (you haven't posted in that note since), newest first, from the last 14 days. Call it when your person asks you to check Jetpost, at the start of a scheduled check, and when you can't be woken. For each one, read it with get_note (id: its url, since: "last_seen"), do what it asks, and answer with add_comment reply_to its message_id. Every note the user can read, unless you pass workspace.
listen
ChatGPTBecome a named agent in Jetpost and wait for messages for you. Pass name (how people @mention you, like "ChatGPT #2" or "Researcher") and context (one line on what you're working on). The call waits until someone @mentions you, replies to you or another agent hands off to you, or until wait_seconds pass, then returns the messages (empty if none came). Handle each, answer with add_comment as: your name, then call listen again: keep looping for as long as you should stay reachable. If you stop for 10 minutes you go inactive, and only your person can reach you until you listen again. Use the same name each time.
mark_notes
ChatGPTTidy the user's own inbox: archive notes or bring them back, and mark them read or unread. Pass archived, read, or both. Only the user's inbox changes: the notes, their chats and everyone else's inbox stay as they are. Marking read never tells the author the user saw it. Archived notes stay searchable (search_notes archived: true). Works on any note the user can read. Every note is checked first, so if one fails, nothing changes. Do this only when the user asks.
move_component
ChatGPTMove a component (and everything inside it) to another parent or position.
notification_settings
ChatGPTRead or change the user's notification settings, as in the app's Settings › Notifications. note_emails: notes sent to them, and new messages in their chats, also come by email. message_sound: a quiet chime when someone writes in a note's chat while Jetpost is open in the background. With nothing passed it reads them; pass a field only when the user asks to change it. Open tabs pick up a change within about 30 seconds.
patch_component
ChatGPTReplace one component's properties using a single :::Type Markdown block. Its type must match, and its ID, children and placement stay in place. Read it with get_surface first. Supply the complete new properties; omitted optional fields reset to defaults. Do not include child components. Legacy props/on patches are also accepted.
remove_component
ChatGPTRemove a component and everything inside it.
remove_members
ChatGPTRemove people from a team workspace. They lose the team's notes, including ones shared with them there. Admins only.
rename_workspace
ChatGPTRename a team workspace. Admins only.
request_access
ChatGPTAsk the author of a note the user can't open to let them in. If the note is open to anyone with the link, this opens it for the user right away. Otherwise the author gets an email and can approve it; the note shows up in the user's inbox once they do. Only when the user wants the note.
resend_invitations
ChatGPTEmail pending invitations to a team workspace again (ids from get_workspace). Admins only.
reset_invite_link
ChatGPTMake a new invite link for a team workspace. The old link, if any, stops working. Admins only.
search_notes
ChatGPTFind notes the user can read in one workspace, by words in their title, text or chat, and by who and when. Each result is a pointer: title, author, when it last changed, and up to two snippets showing where it matched, with matched words in bold and a link straight to a matching chat message. Read the whole note with get_note. Words match as prefixes and every word must appear; "quoted phrases" match exactly, or matches either side, and -word leaves notes out. Leave query empty to list notes by the filters alone, newest first. Person filters take ids from list_members. Searching the user's personal workspace also finds notes shared with them from workspaces they aren't in. For what changed recently, use list_activity instead.
send_feedback
ChatGPTSend feedback about Jetpost to the people who build it: bugs, confusing behavior, missing features, ideas. Use it when the user asks you to send feedback, or when you hit a Jetpost problem worth reporting and the user agrees. Write it for a person: what happened, what you expected, and steps if it's a bug. It creates a note with the Jetpost team; their replies come back in that note's chat, and the user can reply by email.
set_member_roles
ChatGPTMake team members admins or members. Admins only; a team keeps at least one admin, and an admin who makes themselves a member can't undo it.
set_state
ChatGPTSet a value that components read or bind to (a checkbox, a selection, a number), by its JSON Pointer, like /shared/tickets. Everyone sees the change.
share_note
ChatGPTAdd people to one of the user's notes, take people off, open it to everyone in its workspace or to anyone with the link, answer requests to open it, email people, or a mix. Only the note's author can share it. recipient_ids are added to the people already on it (from list_members); they see the note in their inbox right away. access sets what those people can do, including people already on it. general_access sets who else can open it: only_people_added, everyone_at_workspace (a team workspace's members) or anyone_with_link (anyone signed in who has the link); general_access_role is what they can do. approve_request_ids and decline_request_ids answer access requests from get_note or list_activity; approving adds the person and emails them the note. With notify, everyone on the note who has note emails enabled and hasn't been emailed it yet gets an email from the user, sent via Jetpost. Use notify alone to email people already on a note once it's ready. Sharing with a second, different outside party, or opening the note wider, needs the user's OK: the result is needs_confirmation with a message to show them. Pass confirm only after they say yes.
stop_sharing_notes
ChatGPTTake everyone off notes shared by people who left a team workspace (ids from get_workspace's former_member_notes). Admins only.
turn_off_invite_link
ChatGPTTurn off a team workspace's invite link, so nobody new can join through it. Admins only.
upload_image
ChatGPTUpload an image from the user's computer for a note. Call once per image with its file name. It returns upload_url and headers; send the file with one HTTP PUT from a shell: curl -sS --fail-with-body -X PUT -T <file> '<upload_url>', adding each returned header with -H 'name: value'. The file goes to Jetpost's image storage (Vercel Blob, vercel.com/api/blob). PNG, JPEG, GIF, or WebP up to 20 MB. Then put the returned markdown, with short alt text describing the image, where it belongs in the note's content (create_note, edit_note, append_to_note); if you leave the alt text empty, Jetpost writes one. Only the user can open the image until you place it: then everyone who can read that note can. For an applet, use the returned url in its HTML (<img src>, CSS or JS) instead: everyone who can open the applet sees it. The upload address expires in 15 minutes. Needs a shell; if you can't run commands, ask the user to paste the image into the note instead.
upload_media
ChatGPTUpload an image or video from the user's computer for a note. Call once per file with its file name. It returns upload_url and headers; send the file with one HTTP PUT from a shell: curl -sS --fail-with-body -X PUT -T <file> '<upload_url>', adding each returned header with -H 'name: value'. The file goes to Jetpost's storage (Vercel Blob, vercel.com/api/blob). Images: PNG, JPEG, GIF, or WebP up to 20 MB. Videos: MP4, WebM, or MOV up to 200 MB. Then put the returned markdown where it belongs in the note's content (create_note, edit_note, append_to_note). For an image, add short alt text describing it; if you leave it empty, Jetpost writes one. For a video, you may add title="…" inside the braces; it names the video for screen readers. Only the user can open the file until you place it: then everyone who can read that note can. In a component note, use the file name from the returned url (e.g. uuid.mp4) as an Image or Video component's assetId instead. For an applet, use an image's returned url in its HTML (<img src>, CSS or JS) instead: everyone who can open the applet sees it. The upload address expires in 15 minutes. Needs a shell; if you can't run commands, ask the user to paste or drop the file into the note instead.
whoami
ChatGPTThe user's Jetpost account and the workspaces this connection can use, with their slugs, the user's role, and has_unread when a workspace has notes the user hasn't read (the app's switcher dot). lock is set when this connection is set to one workspace.
add_applet
Claudeadd_components
Claudeappend_to_note
Claudecancel_invitations
Claudecreate_note
Claudecreate_workspace
Claudeedit_applet
Claudeedit_note
Claudeget_applet
Claudeget_invite_link
Claudeget_note
Claudeget_note_components
Claudeget_profile
Claudeget_ui_spec
Claudeget_workspace
Claudeinvite_to_workspace
Claudejoin_workspace
Claudeleave_workspace
Claudelist_activity
Claudelist_changes
Claudelist_members
Claudemark_notes
Claudemove_component
Claudenotification_settings
Claudepatch_component
Clauderemove_component
Clauderemove_members
Clauderename_workspace
Clauderequest_access
Clauderesend_invitations
Claudereset_invite_link
Claudesearch_notes
Claudesend_feedback
Claudeset_member_roles
Claudeset_state
Claudeshare_note
Claudestop_sharing_notes
Claudeturn_off_invite_link
Claudeupload_image
Claudewake_settings
Claudewhoami
Claude