Account Tools

Tools callable over account-mcp with a wka_live_* account key. Account keys default to read-only; every grant is explicit and spend-capped.

The account assistant also reaches 669 in-space tools as space_<tool> (each maps to <tool> on the space pages), only in spaces it is allowed into.

AI

check_generation

Scope: ai:run

Check an async generation job (video/music/image) started by generate_image / generate_media. Returns status and result URLs when completed.

evaluate

Scope: ai:run

Judge a piece of text with typed questions (boolean / choice / score) and get probabilities back — for routing, grading and checks, steadier and cheaper than reading a chat model's words. Bills the user wallet (fractions of a cent).

find_for_me

Scope: ai:run

Find things for the person on Wakato: courses, products, services and digital goods on the Wakato Marketplace, communities to join, businesses they can visit (shops, cafés, restaurants, repair, salons, gyms) and public EVENTS (meetups, classes, runs, workshops — online or in person). Use it whenever they want to find, buy, hire, book, learn, join, attend or go somewhere ("a course to lose weight", "someone to fix my bike", "a running group", "coffee near me", "anything fun this weekend"). For events in a time frame pass from/to in their timezone. Pass their words as query and 4–10 related words a seller would use as terms. Returns candidates to choose from; then call show_picks with your 1–5 best. Only Wakato is searched — for anything else use web_search.

generate_image

Scope: ai:run

Generate an image from a text prompt at ACCOUNT level — no space needed. Bills the user wallet as the agent's own spend (key caps apply). Omit model to use the default image model, or pick one from list_available_models (category 'image'). Pass image_url (an https URL — a photo the owner sent in chat, or an asset's file_url) to EDIT/restyle an existing picture instead of generating from scratch: an image-EDITING model is then chosen for you when model is omitted or names a text-to-image model (the result says which ran). Optionally pass save_to_space_id (+ filename) to also file the result into that space's asset library. Slow renders past wait_seconds return a job_id — poll check_generation.

generate_media

Scope: ai:run

Generate video, music, SFX, or other media at ACCOUNT level via any active platform model. Bills the user wallet as the agent's own spend (key caps apply). model is required — pick from list_available_models (category 'video'/'audio'). Pass provider parameters in input (text-to-video: prompt; lip-sync/avatar: image_url + audio_url; music: prompt). Long renders return a job_id — poll check_generation. Optionally save_to_space_id (+ filename) files results into a space's asset library.

generate_speech

Scope: ai:run

Text-to-speech at ACCOUNT level — returns a hosted audio URL. Bills the user wallet as the agent's own spend. Uses the owner's default voice for the model's provider unless params.voice_id is passed. Omit model for the default TTS model.

get_my_model

Scope: ai:run

Read YOUR OWN wiring: the brain model you are thinking with right now, the live-search model web_search runs on, and the models you are allowed to switch to (with pricing and context windows). Use this before answering any question about which model you are — never guess it. Only works for the Account Agent's own key.

set_my_model

Scope: ai:run

Switch YOUR OWN brain model. Pick the best tool for the job — e.g. a stronger model for hard reasoning, a cheaper/faster one for routine work — from the allowed list in get_my_model. Takes effect on your very next model call (no restart). Tell your owner when you switch and why.

set_my_search_model

Scope: ai:run

Switch what YOUR web_search runs on — the live-search model, which is a different thing from your brain model. Pick from get_my_model's selectable_search_models: a fast one for a quick lookup, a reasoning one when the answer has to be weighed, or "pages" to fetch the sources whole and read them with your own brain model. Effective on your next search. Tell your owner what you changed and why.

transcribe_audio

Scope: ai:run

Turn a recording into text at ACCOUNT level (bills the user wallet — about a tenth of a cent a minute). Pass audio_url, a public link to the file. Returns the text and the detected language.

web_search

Scope: ai:run

Search the live web and get a cited answer. Use it for ANYTHING outside the owner's Wakato account: what's near a place, whether somewhere is open, current prices, a company or person, news, how something works. Pass near (a city or neighbourhood — never coordinates) to ground a 'near me' question. Results are what the web says, NOT a live places or hours feed: repeat the freshness_note rather than presenting an opening time as fact. Bills the user wallet as the agent's own spend.

Billing

get_commerce_status

Scope: billing:read

Check whether the account is set up to take payments, in plain terms — read this BEFORE telling the owner how to 'set up' or 'connect' payments. Returns stage (not_set_up | pending | ready), a summary to relay, a next_step (null when ready), and the spaces payments are live on. If it's already ready, there is nothing to set up. Never describe payment setup from memory, and never name the underlying payment provider — Wakato white-labels it; say 'payments' / 'get paid' / 'verify your business'.

get_usage_summary

Scope: billing:read

Recent account wallet transactions plus this key's rolling 30-day spend vs its limit.

Communities

add_community_discussion_reply

Scope: communities:write

Post a reply on a discussion thread (blocked if locked).

add_community_moderator

Scope: communities:write

Promote a user to community moderator. permissions is an object of booleans: approve_members, approve_products, edit_community.

add_community_tab

Scope: communities:write

Add a content tab to a community the account owns. module is a slug from list_community_catalog (about, members, products, feed, events, discussions, resources, rooms, custom_page). config holds module-specific settings, e.g. custom_page → { paper_id }.

approve_community_member

Scope: communities:write

Approve a pending join request. member_id from list_community_members (status='pending').

assign_community_to_space

Scope: communities:write

Set or MOVE the space one of the account's communities is run from (strict 1:1 — a community runs from one space, a space runs one community). Its owner/admins and agent run it; its members become that space's contacts; a paid membership is paid into that space's commerce account.

create_community

Scope: communities:write

Create a community OWNED by this account and RUN FROM one space (space_id, required — a community belongs to a space: its owner/admins and agent run it, its members become that space's contacts, a paid membership is paid into that space's commerce account). REQUIRES OWNER APPROVAL: the first call queues it; after the owner approves, call again with approved_action_id to execute. publish:true goes live immediately; otherwise it's a draft.

create_community_course

Scope: communities:write

Create a classroom course in an owned community (auto-creates a Classroom tab if missing). Add lessons with create_community_lesson.

create_community_discussion

Scope: communities:write

Start a discussion thread in a community the account owns (auto-creates a Discussions tab). Optionally pin/lock or set category_id.

create_community_discussion_category

Scope: communities:write

Create a discussion category (auto-creates a Discussions tab if missing).

create_community_event

Scope: communities:write

Schedule an event at one of the owner's communities (auto-creates that community's Events tab). Every event is held by a community — that is what decides who may come — so community_id is required; use list_communities to find it, or create one first. starts_at is an ISO timestamp; location_type online|in_person. Add cover_url/video_url so the event presents well, and people to bill the hosts and guests. Admission: audience 'community' (every approved member) or 'roles' (only allowed_role_ids); approval_required adds a per-request review; ticket_product_id makes it paid (the marketplace listing IS the ticket); rsvp_form_id attaches registration questions (a Space Form); capacity caps attendance; private_details holds the address/link/instructions revealed only to people who are in.

create_community_lesson

Scope: communities:write

Add a lesson to a classroom course. content is rich text; video_url optional; attachments is an array of {url, name, type}.

create_community_resource

Scope: communities:write

Add a resource to the community library (auto-creates a Resources tab if missing). Provide a url OR a file_url. Optional category groups items.

create_community_role

Scope: communities:write

Create a membership role for a community the account owns (e.g. Member, Seller, VIP). auto_approve grants it without review; is_public shows it on the join page. Attach abilities with set_community_role_permissions, join gating with set_community_role_requirements.

create_community_room

Scope: communities:write

Create a room in a community the account owns. mode audio|video. schedule.mode: always (persistent) | once (set scheduled_start/end) | daily/weekly/monthly (recurring). Access: allowed_roles[]/allowed_members[] (empty = all members); require_approval = waiting room.

delete_community_course

Scope: communities:write

Delete a classroom course and all its lessons. course_id from list_community_courses.

delete_community_discussion

Scope: communities:write

Delete a discussion thread and its replies.

delete_community_discussion_category

Scope: communities:write

Delete a discussion category (threads kept, uncategorized).

delete_community_discussion_reply

Scope: communities:write

Delete a reply from a discussion thread (moderation). reply_id from list_community_discussion_replies.

delete_community_event

Scope: communities:write

Delete a community event. event_id from list_community_events.

delete_community_lesson

Scope: communities:write

Delete a classroom lesson. lesson_id from list_community_lessons.

delete_community_resource

Scope: communities:write

Remove a resource from the community library. resource_id from list_community_resources.

delete_community_role

Scope: communities:write

Delete a community role. Fails if members still hold it — reassign them first with set_community_member_role.

delete_community_room

Scope: communities:write

Delete a community video/voice room. room_id from list_community_rooms.

get_community

Scope: communities:read

Get an owned community's overview: profile, status, member counts (approved/pending/suspended), moderator count, public URL, and member_intro (the members-only welcome note).

get_community_attendance

Scope: communities:read

Room attendance overview for an owned community (mirrors the owner Attendance dashboard): totals, per-member and per-room minutes/sessions. Only tracked rooms count.

get_community_classroom_progress

Scope: communities:read

Classroom completion stats: per-course lesson_count, learners, completed, in_progress. Optional course_id narrows to one course.

get_community_membership_plan

Scope: communities:read

Get the community's active paid membership plan, or free:true if the community is free.

get_community_referral_program

Scope: communities:read

Get a community's Partner commission (referral program) — the cut of member sales the community earns: commission_pct, terms, is_active, version, and how many sellers have agreed. Returns program:null when none is set.

get_community_role

Scope: communities:read

Get one community role in full: its fields, assigned permission tags, and join requirements. role_id from list_community_roles.

get_community_stats

Scope: communities:read

One-call overview of an owned community: member counts, moderators, tabs, roles, and content counts (discussions, events, resources, classroom courses/lessons, rooms) plus paid-membership snapshot.

invite_to_community

Scope: communities:write

Invite people into an owned community by email. Each address gets its own link; someone without a Wakato account signs up and lands in the community. Optionally names the role they are admitted into.

list_communities

Scope: communities:read

List the account's communities and which space (if any) operates each one.

list_community_catalog

Scope: communities:read

Discover the building blocks for community structure: tab_modules (about, members, products, feed, events, discussions, resources, rooms, custom_page…), permission_tags (role abilities), and role_requirement_types (join rules). Call first so add_community_tab / set_community_role_permissions / set_community_role_requirements use valid slugs.

list_community_courses

Scope: communities:read

List an owned community's classroom courses with lesson_count each.

list_community_discussion_categories

Scope: communities:read

List a community's discussion categories.

list_community_discussion_replies

Scope: communities:read

List replies on a discussion thread (oldest first).

list_community_discussions

Scope: communities:read

List a community's discussion threads (pinned first). Optionally filter by category_id.

list_community_event_rsvps

Scope: communities:read

List RSVPs for a community event plus its going_count. event_id from list_community_events (space-side).

list_community_events

Scope: communities:read

List an owned community's events with their line-up, admission settings (audience, allowed_role_ids, approval_required, capacity, ticket_product_id, rsvp_form_id) and private_details (organiser view). upcoming:true filters to future events.

list_community_lessons

Scope: communities:read

List lessons in a classroom course (title, content, video_url, attachments, sort_order).

list_community_members

Scope: communities:read

List a community's members with profile info. Filter by status (pending|approved|rejected|suspended|left).

list_community_moderators

Scope: communities:read

List a community's moderators and their permissions (approve_members, approve_products, edit_community).

list_community_pending_posts

Scope: communities:read

Discussions and replies waiting for review, because their author's role was granted the permission WITH approval.

list_community_recordings

Scope: communities:read

Recorded sessions across an owned community's rooms, newest first, with a playable url when the recording is ready.

list_community_resources

Scope: communities:read

List an owned community's resource-library items (links/files grouped by category).

list_community_roles

Scope: communities:read

List a community's membership roles (id, slug, name, auto_approve, is_public).

list_community_rooms

Scope: communities:read

List a community's video/voice rooms with status and settings.

list_community_tabs

Scope: communities:read

List a community's content tabs in display order (id, slug, name, module, config, sort_order, is_visible).

reject_community_member

Scope: communities:write

Reject a pending join request (optional reason). member_id from list_community_members.

remove_community_member

Scope: communities:write

Permanently remove a member from the community. member_id from list_community_members.

remove_community_membership_plan

Scope: communities:write

Archive the active paid plan and make the community free.

remove_community_moderator

Scope: communities:write

Demote a moderator. moderator_id from list_community_moderators.

remove_community_tab

Scope: communities:write

Remove a community tab (also removes content living on it, e.g. that tab's events/resources). tab_id from list_community_tabs.

reorder_community_tabs

Scope: communities:write

Set a community's tab display order. tab_ids is the full ordered array of tab ids from list_community_tabs.

review_community_post

Scope: communities:write

Approve a pending discussion or reply so everyone can see it, or reject it.

set_community_discovery

Scope: communities:write

Submit an owned community to the Wakato directory for review ('submit'), or take it back out ('withdraw').

set_community_member_role

Scope: communities:write

Assign a community member to a role (omit role_id to clear). member_id from list_community_members, role_id from list_community_roles.

set_community_membership_plan

Scope: communities:write

Set/replace the community's paid membership plan. billing one_time|subscription; price_cents ≥ 100; subscription needs billing_interval month|year. Archives any current plan.

set_community_referral_program

Scope: communities:write

Set (or replace) a community's Partner commission — the % of member sales the community keeps. commission_pct 0–50. terms optionally describes what sellers get for it (omit/null keeps existing terms). is_active defaults true; false pauses new agreements. Rate changes bump the program version: sellers who accepted an older rate keep it until they accept the new one.

set_community_role_permissions

Scope: communities:write

Replace a role's abilities. permissions is the full array of permission-tag slugs from list_community_catalog. Empty array clears them all.

set_community_role_requirements

Scope: communities:write

Replace a role's join requirements. requirements is the full ordered array of { rule_type, config } using rule_type slugs from list_community_catalog (kyc_verified, email_verified, profile_complete, has_tag {tag_slug}, answers_custom_question {question,…}, min_account_age_days {days}). Empty array clears them.

suspend_community_member

Scope: communities:write

Suspend a member (revokes access, keeps the row). member_id from list_community_members.

unassign_community_from_space

Scope: communities:write

A community always belongs to a space and cannot be disconnected — this refuses with a sentence; move it with assign_community_to_space instead. (Kept one release for older callers.)

update_community

Scope: communities:write

Edit a community the account owns: name, description, short_description, logo_url, banner_url, visibility, category, media (gallery [{ id, type, url, thumbnail_url, caption }]), and member_intro (the members-only welcome note — markdown, readable only by members; description stays the public visitor pitch). (The community's cut of member sales is the Partner commission — see get/set_community_referral_program.)

update_community_course

Scope: communities:write

Edit a classroom course (title, description, cover_url, sort_order). course_id from list_community_courses.

update_community_discussion

Scope: communities:write

Edit a discussion thread — title/body, pin/lock, or category. discussion_id from list_community_discussions.

update_community_event

Scope: communities:write

Edit a community event, including its admission controls (audience/allowed_role_ids, approval_required, ticket_product_id, rsvp_form_id, capacity, private_details — same semantics as create_community_event; private_details: null wipes the joining details). event_id from list_community_events. Passing people REPLACES the whole line-up — read it from list_community_events first and send the full list you want.

update_community_lesson

Scope: communities:write

Edit a classroom lesson (title, content, video_url, attachments, sort_order). lesson_id from list_community_lessons.

update_community_membership_plan

Scope: communities:write

Patch the community's ACTIVE paid membership plan in place (price, interval, granted role, lapse behavior).

update_community_moderator

Scope: communities:write

Update a moderator's permissions. moderator_id from list_community_moderators.

update_community_resource

Scope: communities:write

Edit a resource in the community library. resource_id from list_community_resources (space-side).

update_community_role

Scope: communities:write

Edit a community role's fields (name, description, icon, color, auto_approve, is_public, sort_order). role_id from list_community_roles.

update_community_room

Scope: communities:write

Edit a community room (title, description, recording, schedule, access control). room_id from list_community_rooms.

update_community_tab

Scope: communities:write

Edit a community tab (name, icon, visibility, sort_order, or merge into its config). tab_id from list_community_tabs.

Computers

activate_space_agent

Scope: computers:write

Put an agent back on a runtime the owner already has — one that was deactivated with deactivate_space_agent, or an empty container on a computer they brought. NOT the way to make an agent: that is create_agent, which makes the container too. One agent per container: a runtime that already powers a different agent refuses. The agent — not the machine — carries where it works: home_space_id is the space whose wallet pays for its thinking (fixed for its life), and space_ids are the other spaces it may act in (the owner must be an admin of each). Engines: hermes (default) and dsh think on the space gateway and can be set up entirely from here; claude_code, codex, grok and opencode run on the owner's OWN provider account and are signed in from the New agent screen in Messages — you cannot do that from here. A model is required for the gateway engines and must be one the home space's gateway allows (list_space_models). Minting the credential is owner-approved: the first call queues an approval; once approved, call again with { approved_action_id }. Standing instructions are set with set_agent_instructions; day-to-day you steer the agent by messaging it, and change its model with set_space_agent_model.

buy_proxy

Scope: computers:write

Buy a residential proxy for the owner — a real IP in a country (and city) you pick, charged to the owner's wallet monthly. Call list_proxies first: a free one they already pay for should be used instead. The price is quoted live and shown in the approval; it is spend-capped AND owner-approved — the first call queues an approval; once approved, call again with { approved_action_id }. Pass browser_id to put it on that browser the moment it is bought (a browser already on a proxy is switched). To make a NEW browser on it, buy first, then create_browser with the proxy_id this returns.

cancel_agent_schedule

Scope: computers:write

Cancel one of an agent's alarms (id from list_agent_schedules). A recurring one stops for good. No approval needed.

cancel_proxy

Scope: computers:write

Cancel a proxy — it stops renewing and its monthly charge ends. It KEEPS WORKING until the day the owner already paid for (works_until in the result), then it is gone; a browser on it keeps browsing from it until then and falls back to the machine's own connection after. Nothing is refunded (nothing more is charged). Owner-approved: the first call queues an approval; once approved, call again with { approved_action_id }. keep_proxy undoes it while works_until is still ahead.

cancel_sign_in

Scope: computers:write

Abandon a sign-in started with start_sign_in and release its machine. Use it when the owner changes their mind or the link expired unused; start_sign_in makes a fresh one. Never call it on a draft that check_sign_in reported connected and you are about to build on.

check_sign_in

Scope: computers:read

Where a sign-in started with start_sign_in stands: still waiting for the owner (the link and code again), connected (their account, and the sign-in now SAVED for every future agent — sign_in_id), or ended without connecting. Call it when the owner says they have signed in. On connected, the next step is create_agent with the same engine and this draft_id.

close_browser

Scope: computers:write

Close one of the owner's browsers: release its hold, stop it, put its own machine to sleep (nothing billed while closed; tabs and sign-ins are kept). Whoever opened it, you may close it when the owner asks. No approval needed.

connect_my_server

Scope: computers:write

Connect a machine the owner ALREADY has — a VPS/dedicated box (e.g. Hostinger, a datacenter server) or the very computer you are running on — as a computer that can power their agents. No rental, $0/mo; adding a computer needs a Business plan. It belongs to the account, not to a space; the agent on it is what carries spaces. Use this INSTEAD of create_computer whenever the owner wants to reuse their own hardware rather than rent one — and remember an agent needs no computer at all (create_agent). It returns a one-time install_command: run it ON the target machine — locally on the box you're on, or over your own SSH session to the server. The machine connects OUTBOUND through a secure tunnel (no inbound ports opened, and no SSH credentials are ever handed to Wakato). It registers itself in ~1-2 minutes; then poll list_computers until this computer's status is 'running', then create_agent with computer_id. The install_command expires in 1 hour — call this again for a fresh one.

create_agent

Scope: computers:write

Make an agent for the owner. It is a person in Messages: a name, a face, a home space whose wallet pays for its thinking, permissions, its own chat. It runs in its own container on Wakato's cloud — nothing to rent, size or assign; it wakes when someone talks to it and sleeps when they don't, and the owner pays only for the compute it actually uses (capped, default $50/mo). This is THE way to make an agent; a 'Reach' or a 'Space Computer' is not a thing. Two KINDS: 'work' (default) is its team's — it belongs to home_space_id, whose owner runs it and pays. 'public' is the one the WORLD meets: it gets a space of its own (made here — leave home_space_id out), a username @agent.<username> chosen once, and a Wakato profile people can follow and message; use it when the owner wants an agent for customers, fans or the public. After a public agent is born, wire its space with set_up_space (budget, domain, mailboxes, connected accounts, models). Call list_agents first so you do not make a second agent for a job one already has. Engines: hermes (default) and dsh think on the home space's gateway and need a model (list_space_models). claude_code, codex, grok and opencode run on the owner's OWN provider account: the FIRST sign-in for an engine happens once, from the New agent screen in Messages, and after that its saved sign-in is reused — call list_saved_sign_ins (or list_agent_engines) and, when the owner has several, pass sign_in_id; with none saved for that engine the call refuses and says so. computer_id (from list_computers) puts it on a computer the owner brought instead of the cloud — only when they asked for that. reach=true switches on its Reach — the harness that answers as this agent to the outside world (phone, widget, WhatsApp/SMS/email, social inboxes) — which you then configure with set_agent_reach and the space_*_agent_reach tools. Owner-approved: the first call queues an approval; once approved, call again with { approved_action_id }. The agent and its chat exist as soon as that returns, but its machine takes ~20 more seconds to come online — say it is starting, not that it is ready, or the owner's first message sits unanswered and reads as broken. After that, give it work with message_agent. Its standing instructions — what it knows from day one — go in instructions here (or set_agent_instructions later); everything else you steer by talking to it.

create_browser

Scope: computers:write

Make a browser — an identity toward the web on a machine of its own: its own logins and cookies, its own proxy if you give it one, and an ACCESS LIST of agents that may use it (any number; the owner can open it with none). Every agent already has one of its own; make another when agents need a second account or need to be somewhere else. name is required (short, like 'instagram-1'). agent_ids (from list_agents; each must have a machine) are given access right away. proxy_id is a proxy the owner already has and is free (list_proxies); to buy a new one, call buy_proxy first (owner-approved) and pass what it returns. No approval needed: nothing is spent until it is opened (its machine is billed while awake, like an agent's) and it can be deleted. The owner then signs in BY HAND in Backstage → Browsers (Open) — you cannot sign in for them and never type a password; say so in your reply.

create_computer

Scope: computers:write

Rent a new Cloud Server — a computer of the owner's own that can power agents. RARELY THE RIGHT TOOL: agents run on Wakato's cloud, so create_agent makes one with no server, no rent and no waiting. Use this ONLY when the owner has explicitly said they want a machine of their own — never as the way to give somebody an agent, and never offer it as a suggestion. Adding a computer needs a Business plan. It belongs to the ACCOUNT, not to a space — do not ask the owner which space it is for; the agent on it is what carries spaces. Charges the wallet monthly, so it is spend-capped AND owner-approved: the first call queues an approval; once approved, call again with { approved_action_id }. BEFORE calling this, call list_computers: if one is already 'running', do NOT rent another — create_agent with its computer_id puts an agent on it for free. Call list_computer_sizes to see the options and pass a size_id yourself — never ask the owner for a raw id. Provisioning is async (~2-3 min) — poll list_computers until status is 'running', then create_agent with computer_id.

deactivate_space_agent

Scope: computers:write

Retire an agent that runs on a computer the owner brought — revokes its credential and disconnects it; the computer, its container and its memory stay, and activate_space_agent brings it back. For an agent on Wakato's cloud use delete_agent. Owner-approved: the first call queues an approval; once approved, call again with { approved_action_id }.

decide_agent_permission_request

Scope: computers:write

Answer an agent's permission request (from list_agent_permission_requests) as the owner: 'allowed' widens the agent from now on (it lands on its Can do list; the owner can take it back on the agent's page), 'allowed_once' lets it use the permission for the next hour only, 'refused' closes it. The agent is told in its chat and carries on. Only after the owner has said which — read the request back to them first.

delete_agent

Scope: computers:write

Remove one of the owner's agents for good — revokes its credential, archives its chat, and tears down the container it lived on (on Wakato's cloud) so it stops holding a slot. An agent on a computer the owner brought is RETIRED instead (credential revoked, chat archived) and its container stays on that computer for the owner to remove; an agent waiting for a computer is simply deleted. Pass the agent_id from list_agents. Owner-approved and NOT reversible: the first call queues an approval; once approved, call again with { approved_action_id }. Its history is kept but does not come back on a new agent with the same name, so say that plainly before asking.

delete_browser

Scope: computers:write

Delete a browser for good — its machine and its logins are gone, every agent loses access, and its proxy is freed (the proxy stays the owner's and keeps renewing; cancel_proxy stops that). The browser an agent was born with cannot be deleted; it goes when the agent does. Owner-approved and NOT reversible: the first call queues an approval; once approved, call again with { approved_action_id }.

get_agent_can_use

Scope: computers:read

"Can use" — WHICH things one of the owner's agents may touch in each space it works in, on top of its permissions (get_agent_permissions says what KINDS of action; this says which tables, documents, apps, pages, forms, asset folders, automations and secrets), and HOW FAR with each. Per kind: "all" (every one at the top), a list of {id, name, level} (only those), or {every_one_at, except: [{id, name, level}]} (every one at a step, the named ones different — "hidden" = it cannot see that one). Read it before changing it, so a narrowing keeps what the owner meant to keep.

get_agent_permissions

Scope: computers:read

What one of the owner's agents may do, and which of those powers stop and ask the owner first. Pass the agent_id from list_agents. Read this before changing anything, so a narrowing does not quietly drop a permission the owner still wants.

get_agent_reach

Scope: computers:read

One of the owner's agents' Reach — the harness that, switched on, answers as that agent to the outside world: whether it is on, its per-platform settings (enabled, what it may do there, its instructions there, its limits there), which platforms are actually CONNECTED (a number, a mailbox, a widget, a social account), and the catalogue of platforms/actions/limits you may set. reach is null until the agent is put on the harness (set_agent_reach on=true). Settings may be written for a platform before it is connected; connecting itself (numbers, mailboxes, social accounts, the widget) is done on the agent's page or with the space_*_agent_reach tools.

get_computer_metrics

Scope: computers:read

Read a running Cloud Server's live host metrics: CPU %, core count, memory used/total + %, disk used/total + %, uptime, and per-workspace CPU/memory. Returns metrics:null with a message if the Cloud Server isn't running or can't be reached. No infrastructure identifiers are returned.

give_browser

Scope: computers:write

Give an agent ACCESS to a browser — it joins the browser's access list beside whoever already has it (other agents keep theirs), sees what is signed in there, and works in a tab of its own in the same live browser. Its machine is told right away; nothing is woken. The browser an agent was born with is that agent's alone and cannot be shared. No approval needed. To take access away, take_browser_access.

keep_proxy

Scope: computers:write

Undo a cancellation — turn a cancelled proxy's renewal back on while it is still working (works_until ahead). It renews on works_until at its monthly price, charged to the owner's wallet, so it is owner-approved: the first call queues an approval; once approved, call again with { approved_action_id }. A proxy that has already ended cannot be kept — buy_proxy instead.

list_agent_engines

Scope: computers:read

The engines an agent can run on, and what each one needs. Call this BEFORE create_agent or activate_space_agent instead of guessing: it says which engines think on the space gateway (hermes, dsh — this assistant can set those up completely) and which run on the owner's own provider account and are signed in from the New agent screen in Messages (not from here). Pass a workspace_id to also see what is already on that runtime — one agent per container.

list_agent_permission_requests

Scope: computers:read

What the owner's agents are WAITING ON: permissions they asked for and nobody has answered — an agent files one from its chat when a task needs a power it does not hold (a card sits on its message there too). Each row says the agent, the space, the permission (category · action), the agent's own reason, and unlocks — what saying yes lets it do from now on. Answer the owner in those words; then decide_agent_permission_request when they say so.

list_agent_schedules

Scope: computers:read

What one of the owner's agents has planned — every alarm still to fire, with when and who set it (the agent, the owner, or you).

list_browsers

Scope: computers:read

Every browser the owner has — its proxy (or the machine's own connection), what it is signed in to, its About, and who may use it: a default (kind 'default') is the browser an agent was born with and lists that one agent; an extra lists the AGENTS WITH ACCESS (any number, possibly none — the owner can still open it themselves). Read this before create_browser (to reuse a proxy or avoid a duplicate name) and before give_browser.

list_computer_sizes

Scope: computers:read

List the Cloud Server sizes available to rent, each with a friendly name, specs (vCPU/RAM/disk), monthly USD price, and the locations it's offered in. Only relevant when the owner has explicitly asked for a machine of their own — an agent needs none. Use this to pick a size_id yourself for create_computer and to show the owner the options — never ask the owner for a raw id.

list_computers

Scope: computers:read

The computers the owner BROUGHT — their own server, a home computer, or a Cloud Server rented from Wakato — each with its size (vCPU/RAM/disk), status, location, and the containers on it, one agent each (engine, model, home space, the spaces it reaches). Agents on Wakato's cloud are NOT here, because they have no computer to list: list_agents is the list of agents. A computer belongs to the ACCOUNT, not to a space, and is only a power source — putting an agent on one is create_agent with computer_id. Most owners have none, and that is normal. The account agent's own container is off limits and is managed only in the Wakato UI.

list_proxies

Scope: computers:read

The proxies the owner has — residential IPs bought through Wakato, each a 30-day subscription — with the place, the monthly price, whether it renews (renews=false means it was cancelled and works until works_until, then it is gone), and which browser is on each. A proxy can be on ONE browser at a time. Read this before buy_proxy: a free one the owner already pays for should be used first.

list_saved_sign_ins

Scope: computers:read

The owner's saved sign-ins for the harnesses that run on their OWN provider account — Claude Code, Codex, Grok, OpenCode. Each is a sign-in the owner did once on the New agent screen; every further agent on that engine can be made on it from here (create_agent with that engine, and sign_in_id when there are several). account is what the sign-in is known as (e.g. the account it belongs to); needs_refresh means it stopped working on a new agent and must be signed in again on the owner's screen. The credential itself is never shown or read here. Empty for an engine = the owner has never signed in to it, and the first time has to happen on their screen.

open_browser

Scope: computers:write

Open one of the owner's browsers and KEEP IT OPEN — awake, billed, until someone closes it (the owner from Backstage, an agent, or you with close_browser). Not for browsing: an agent's browser opens itself when the agent works. This is for "put the game on", "leave that page up" — something running with nobody driving it. Wakes a sleeping machine (a minute). A browser nobody touches for hours closes itself. No approval needed.

pause_agent

Scope: computers:write

Pause one of the owner's agents: it keeps its name, chat, files, permissions and External Reach settings, but stops answering — messages sent to it wait, its scheduled tasks are skipped (recurring ones run again at their next time), its External Reach stays silent on every platform (messages still land for the owner), and its machine sleeps and bills nothing. Reversible with resume_agent. Use this when the owner wants an agent stopped for now without deleting it. Pass the agent_id from list_agents. No approval needed.

resume_agent

Scope: computers:write

Resume a paused agent (list_agents shows paused=true). It comes back exactly as it was — same key, chat, files and permissions — and reads what arrived while it was paused; a skipped recurring task runs again at its next time, not now. Owner-approved because a running agent is a bill again: the first call queues an approval; once approved, call again with { approved_action_id }. Pass the agent_id from list_agents.

schedule_agent_task

Scope: computers:write

Set an alarm FOR one of the owner's agents: at the time, a note lands in that agent's chat, wakes it, and it does what the note says — "every weekday at 09:00, check the mailbox and report", "in 60 minutes, close the browser". Use it when the owner wants an agent to do something later or on a schedule; the agent never stays awake waiting. prompt is written TO the agent, second person, complete enough to act on alone. When: in_minutes, or at (ISO 8601; a bare YYYY-MM-DDTHH:MM is read in the owner's timezone), or time_of_day (HH:MM, next such time; with recurrence it repeats). The owner sees it on the agent's page and may cancel. No approval needed.

set_agent_can_use

Scope: computers:write

Change WHICH things one of the owner's agents may touch in ONE space — the "Can use" row on its page — and HOW FAR with each. Pass the whole map for that space. Per kind (tables, documents, apps, pages, forms, asset_folders, automations, secrets) one of: "all" or left out (every one, at the top); a LIST ["<id>" | {"id": "<id>", "level": "<step>"}] (only those; a bare id = the top; [] = none); or EVERY ONE AT A STEP, EXCEPT — leave the kind out and pass default_levels: {"<kind>": "<step>"} with levels: {"<kind>": {"<id>": "<step>" | "hidden"}} ("hidden" = it cannot see that one; new ones arrive at the default step). Steps, bottom first — tables: read < edit < fill < change; apps: read < use < build; pages: read < content < edit < change; documents: read < comment < edit < change; forms: read < submit < edit < change; asset_folders: read < add < change; automations: read < run < edit < change; secrets: use; projects: read < update < add < change; mailboxes: read < reply < send < campaigns; phone_numbers: read < reply < text < campaigns; ad_accounts: read < draft < spend; communities: read < post < moderate < change; calendars: busy < read < add < change. tables: edit = change what existing rows say, fill = also add/remove rows, change = also columns/views/settings/delete; apps: use = records and running it, build = also its code/publishing/sharing; pages: content = swap a picture or pin a product, edit = rewrite it, change = also publish/delete; documents: comment, edit = change the words, change = share/move/delete; forms: submit = send answers through it, edit = its questions, change = publish/delete; asset_folders: add = put files and folders in it, change = rename/move/delete (a folder covers everything under it); automations: run, edit = its trigger and steps, change = switch on/off, delete; a secret is only used, never read. Below its step the agent is refused by name, never asked. Pass null (or an empty map) for everything. Ids come from the space tools (space_list_tables, space_list_documents, space_list_apps…); asset folders are the space's tree (space_list_asset_folders). Call get_agent_can_use first — this REPLACES the space's map, it does not merge. Lands on the agent's next call; a widening at once, a narrowing within a minute.

set_agent_engine

Scope: computers:write

Change which harness one of the owner's agents runs on — e.g. a Grok agent that isn't giving the output they want, switched to Codex, Claude Code, Hermes or Wakato One (dsh) without losing anything. The agent keeps its identity and chat, its files on the machine, its memory, its permissions and its reach — only the engine underneath changes, and its first turn on the new harness reads the conversation so far. For a gateway engine (hermes, dsh) pass a model the home space allows (list_space_models). For a bring-your-own engine (claude_code, codex, grok, opencode) it goes on a saved sign-in — pass sign_in_id to choose one (list_saved_sign_ins), otherwise the most recent is used; if none is saved, tell the owner to sign in once from New agent first. The switch waits for any task in progress to finish — if the agent is working, it says so and nothing changes. Wakes the agent's machine if asleep. No approval needed (no new spend beyond the agent's own thinking).

set_agent_instructions

Scope: computers:write

Set an agent's standing instructions — what it knows from day one: what it is for, how the owner likes things done. Written as a brief to a new employee, in plain English; the agent reads it at the top of every session. Name the space's things with the chat's @-mention grammar (@integrationLabel, document:, page:) — a reader clicks them and the agent gets the handle. Replaces the whole text (read it back with list_agents first if you are adding to it, and keep every @-tag you are not changing). An empty string clears it. Every change is kept in the agent's History and shown as a line in its chat. No approval needed.

set_agent_permissions

Scope: computers:write

Change what one of the owner's agents may do. Pass a preset ('full', 'standard', 'read') for the whole shape, or permissions as a map of category → action → true for exact control — call get_agent_permissions first and send the FULL map you want, because this replaces the old one rather than merging into it. ask_first is the separate list of powers that must stop and ask the owner; send it explicitly (an empty object clears every gate) — omit it and the existing gates are left alone. Takes effect immediately, with no restart.

set_agent_reach

Scope: computers:write

Put one of the owner's agents on the Reach harness, switch the harness on or off, or set ONE platform's settings — in any combination. on flips the harness (true also creates the Reach if the agent has none). platform + settings writes that platform: { enabled, allowed: {action: true|false}, instructions (how to reply THERE — on a social platform this is the DM box; up to 8000 chars, @-mentions of the space's tables/documents/pages allowed), situation_instructions: {comment|story_mention|review|reply: text} (a box per situation the platform has — how to reply to a comment on its post, a story mention, a review, a reply; "" clears one), limits: {key: number|null} } — keys from get_agent_reach's catalogue; unknown keys are dropped, and the merge happens in the database so a second save never loses the first. Settings may be written before the platform is connected. No approval needed: the owner granted this when they made the agent. Connecting numbers, mailboxes, social accounts or the widget is done on the agent's page or with the space_*_agent_reach tools; test what it would answer on a platform with space_test_agent_reach (the owner sees the test in the Test zone).

set_agent_sign_in

Scope: computers:write

Move one of the owner's existing Claude Code / Codex / Grok / OpenCode agents onto a saved sign-in (sign_in_id from list_saved_sign_ins) — e.g. after the owner signed in to a different account, or to refresh an agent whose sign-in expired. The sign-in is put on the agent's machine and checked right there; if it does not work the call says so and nothing changes. No approval needed. Wakes the agent's machine if it is asleep.

set_agent_spaces

Scope: computers:write

Set the OTHER spaces one of the owner's agents may act in, besides its home space (which is fixed for its life and always included). Send the full list you want — spaces left out are taken away, spaces added are granted with the agent's own permissions. The owner must own or admin each. Takes effect on the agent's next tool call; no restart, no approval.

set_browser_proxy

Scope: computers:write

Put a proxy the owner already has on a browser, or take it off (proxy_id omitted = the machine's own connection, shared with other machines on Wakato). The proxy must be free — one browser per proxy. Takes effect at the browser's next open. No approval needed. To buy a new proxy for it, use buy_proxy with browser_id instead.

set_space_agent_model

Scope: computers:write

Switch the model (brain) of one of the owner's agents. Takes effect on its next turn. Only the gateway engines (hermes, dsh) have a model to set — a CLI engine's model comes from the owner's own provider login. No approval needed (no new spend or credential).

set_space_agent_model_policy

Scope: computers:write

Set whether an agent may pick its own model, and the list it may choose from. No approval needed.

start_sign_in

Scope: computers:write

Get a Claude Code, Codex or Grok sign-in READY for the owner, from this chat: prepares a machine, starts the harness's own login there, and hands back the link (and code) the owner opens on any screen — the same card the New agent screen shows, without the screen. Use it when the owner wants an agent on one of those engines and list_saved_sign_ins has nothing usable for it (an already-saved sign-in needs none of this: create_agent reuses it). Relay the link as clickable markdown and the code in bold; say what the page will do (next tells you, per engine). Then: check_sign_in when they say they are done (Codex, Grok), or submit_sign_in_code with the code they send back (Claude Code). Once connected, the sign-in is SAVED for every future agent, and create_agent with draft_id makes the agent on that very machine. Nothing sensitive is handled by you: never ask for a password, and the only thing you ever pass on is the short code the page shows. OpenCode signs in with an API key instead — that goes through the New agent screen. fresh=true signs in to ANOTHER account when one is already saved. Takes up to a minute or two while the machine starts.

submit_sign_in_code

Scope: computers:write

For a Claude Code sign-in: pass the code the owner sent back after signing in on the page (start_sign_in told you when this applies). The code is typed into the login over there; the answer says whether it is now connected — on connected the sign-in is saved and create_agent with draft_id is the next step. Codex and Grok never need this: their code goes the other way (the owner types it on the page).

take_browser_access

Scope: computers:write

Take an agent's access to a browser away. The browser, its logins and every other agent's access stay as they are; the agent's machine is told right away. No approval needed.

Domains & DNS

add_dns_record

Scope: domains:write

Add a DNS record to a Wakato-purchased domain. REQUIRES OWNER APPROVAL: first call queues it; after approval, call again with approved_action_id.

assign_domain_to_space

Scope: domains:write

Assign one of the account's domains to a space (reversible; no DNS change).

delete_dns_record

Scope: domains:write

Delete a non-system DNS record from a Wakato-purchased domain. REQUIRES OWNER APPROVAL (same two-call flow as add_dns_record).

list_dns_records

Scope: domains:read

List a domain's DNS records (domains purchased through Wakato).

list_domains

Scope: domains:read

List the account's domains with verification/SSL status, expiry, auto-renew, space assignments, email (Agent Mail) status, and points_to — what each address serves today (a page, an app, or forwarding to another website).

purchase_domain

Scope: domains:write

Buy a domain (1 year, auto-renews yearly against the account wallet). REQUIRES OWNER APPROVAL: the first call prices it and queues the purchase; after the owner approves, call again with approved_action_id to execute. Counts against this key's spend limit. The domain arrives pointed at Wakato and email-ready. Optionally assigns it to a space.

remove_domain_forwarding

Scope: domains:write

Stop forwarding a domain (or one path on it) elsewhere. The address then serves nothing until a page or app is pointed at it.

search_domains

Scope: domains:read

Check domain availability and pricing. Pass a full domain (example.com) or a bare name to check common TLDs.

set_domain_forwarding

Scope: domains:write

Send everyone who visits one of the account's domains to another website (a redirect). Use this to park a domain on a site the owner already runs — DNS records cannot do this. REQUIRES OWNER APPROVAL: the first call queues it; after the owner approves, call again with approved_action_id. Replaces whatever that address serves today (list_domains shows it under points_to). Works on any verified domain, bought here or connected.

toggle_domain_auto_renew

Scope: domains:write

Turn yearly auto-renew on or off for a domain purchased through Wakato.

unassign_domain_from_space

Scope: domains:write

Remove a domain's assignment to a space.

update_dns_record

Scope: domains:write

Update a non-system DNS record on a Wakato-purchased domain. REQUIRES OWNER APPROVAL (same two-call flow as add_dns_record).

Funds & Budget

allocate_space_funds

Scope: funds:write

ADD budget to a space from the account wallet (top-up, never a replacement). Counts against this key's rolling 30-day spend limit. Check get_space_allocation first — don't allocate to a space that already has budget.

get_space_allocation

Scope: funds:read

Read one space's budget allocation (allocated / spent / remaining).

get_wallet

Scope: funds:read

Read the account wallet: total balance, unallocated amount, and per-space budget allocations.

reclaim_space_funds

Scope: funds:write

Reclaim unspent budget from a space back to the account wallet (does not count against the spend limit).

Gateway Models

disable_space_model

Scope: models:write

Remove a model from a space's gateway.

enable_space_model

Scope: models:write

Enable a model on a space's gateway so agents and apps in that space can use it.

list_available_models

Scope: models:read

List the platform model catalog (model_key, vendor, category, capabilities).

list_space_models

Scope: models:read

List the models enabled on a space's gateway.

Integrations

add_integration_action

Scope: integrations:write

Add an action (a callable endpoint) to a custom integration. Once the integration is assigned to a space, each action becomes a tool that space's agents can call.

assign_ad_account_to_space

Scope: integrations:write

Give a space access to a connected ad account (from list_integrations) so its agents can create/manage campaigns on it. REQUIRES OWNER APPROVAL (two-call flow).

assign_bank_account_to_space

Scope: integrations:write

Give a space access to a connected bank account (from list_integrations) so its finance surfaces can use it. REQUIRES OWNER APPROVAL (two-call flow).

assign_composio_connection_to_space

Scope: integrations:write

Give a space access to a connected third-party app (Composio — Gmail, Outlook, Calendar…, from list_integrations) so its agents can use it. REQUIRES OWNER APPROVAL (two-call flow).

assign_custom_integration_to_space

Scope: integrations:write

Give a space access to a custom integration — its agents can then call the integration's actions. REQUIRES OWNER APPROVAL (two-call flow).

assign_social_account_to_space

Scope: integrations:write

Give a space access to a connected social account (from list_integrations) so its agents can post/manage DMs on it. REQUIRES OWNER APPROVAL (two-call flow).

create_custom_integration

Scope: integrations:write

Build a custom integration to ANY REST/HTTP API (GoHighLevel, HubSpot, an internal service…) so your agents can call it. Provide the base URL, how it authenticates, and optionally its actions (endpoints). Any credentials go straight to encrypted Vault and are never readable back. Executes immediately; the integration is UNASSIGNED until you call assign_custom_integration_to_space (owner approval). If the OWNER must supply the API key, capture it with request_secret_input first — never ask them to paste a key into chat.

delete_custom_integration

Scope: integrations:write

Permanently delete a custom integration (and its actions, events, and space assignments). Its stored credentials are wiped from Vault.

delete_integration_action

Scope: integrations:write

Remove an action from a custom integration.

list_custom_integrations

Scope: integrations:read

List the account's custom API integrations in detail — base URL, auth type, every defined action (endpoint), and which spaces each is assigned to. Use before add_integration_action / update_custom_integration.

list_integrations

Scope: integrations:read

See EVERY connected integration across the account and which spaces can use each: custom API integrations, social accounts, ad accounts, bank accounts, and third-party apps (Composio). Each item includes the id + the assign_with tool to hand it to a space. (Professional email and domains have their own tools: list_email_addresses, list_domains.)

list_phone_connector_shares

Scope: integrations:read

Which spaces the owner has lent their PHONE's calendar or contacts to. The phone syncs those into the space's calendar and contacts (when the Wakato app is open); each share says when it last synced and how many items.

share_phone_connector_with_space

Scope: integrations:write

Lend the owner's phone Calendar or Contacts to a space: from then on the phone syncs them into that space's calendar or contacts, for its members and agents. REQUIRES OWNER APPROVAL (two-call flow). The owner can also do it themselves on the phone: Settings → Assistant → Connectors.

unassign_ad_account_from_space

Scope: integrations:write

Revoke a space's access to an ad account.

unassign_bank_account_from_space

Scope: integrations:write

Revoke a space's access to a bank account.

unassign_composio_connection_from_space

Scope: integrations:write

Revoke a space's access to a third-party app connection.

unassign_custom_integration_from_space

Scope: integrations:write

Revoke a space's access to a custom integration.

unassign_social_account_from_space

Scope: integrations:write

Revoke a space's access to a social account.

unshare_phone_connector_from_space

Scope: integrations:write

Stop lending the owner's phone Calendar or Contacts to a space. Mirrored events leave the space calendar; contacts already synced stay, like a form lead.

update_custom_integration

Scope: integrations:write

Update a custom integration's metadata (name/description/base_url/category/instructions/data_flow_mode), disable/enable it (status), or rotate its credentials. Credentials go straight to encrypted Vault.

update_integration_action

Scope: integrations:write

Edit an existing action on a custom integration (any of method/path/headers/body_template/parameters/etc.).

Members

invite_to_space

Scope: members:write

Send an email invitation to join a space. REQUIRES OWNER APPROVAL: the first call queues it and the owner gets an Approve/Reject card in chat; after they approve, call again with approved_action_id to send. An invite emails a real person and grants them standing access to the space, so it is gated the same way outbound email is.

list_space_members

Scope: members:read

List a space's members (user ids and roles).

remove_space_member

Scope: members:write

Remove a member from a space. The space owner cannot be removed. REQUIRES OWNER APPROVAL: the first call queues it and the owner gets an Approve/Reject card in chat; after they approve, call again with approved_action_id to execute. The person loses access immediately and is not notified, so the owner decides.

Messaging

cancel_schedule

Scope: messaging:write

Cancel a reminder, brief or watch by its schedule_id (from list_schedules).

check_agent_replies

Scope: messaging:read

Look for an agent's reply using the reply_cursor from message_agent, waiting up to wait_seconds (max 20). Returns any replies plus a fresh cursor; still_writing with a partial means it is mid-answer. An empty result is NOT a failure — the machine may simply still be working, so hand the cursor to watch_for_reply rather than telling the owner there was no answer.

list_agents

Scope: messaging:read

The owner's agents — every one they have made (Hermes, Wakato One, and the coding CLIs Claude Code / Codex / Grok / OpenCode), plus their Account Computer agent if they have one. Returns each one's agent_id, kind (work = its team's, belongs to its space; public = the one the world meets, in a space of its own, with its username @agent.<name> and a profile; helper = a private helper of a public agent), engine, home space, what it runs on (Wakato's cloud, or a computer the owner brought), tools — what it HAS on its machine (a real Chrome browser, terminal, files, code, memory) — and can, the Wakato areas its permissions allow, plus whether its Reach is on, what it is working on, and whether it is online (wakes_on_message=true means asleep, not gone). no_computer=true means it is waiting for a computer and cannot work yet. Call this before relaying work to one — read tools rather than guessing whether an agent can browse — and before create_agent so you do not make a second agent for a job one already has.

list_conversations

Scope: messaging:read

The owner's Wakato messages — their direct chats and group chats, newest first, with who each is with, unread counts and a preview of the last message. Use it for 'any messages?', 'what did they say?', 'anything I missed'. A conversation whose with_kind is 'agent' carries an agent_id: relay to that one with message_agent, not send_message.

list_schedules

Scope: messaging:read

Everything you are currently set to do later for this owner: reminders, recurring briefs, and replies you're waiting on. Use it for 'what reminders do I have', and before adding one that may be a duplicate.

message_agent

Scope: messaging:write

Send a message to one of the owner's agents (agent_id from list_agents) in its own chat, as the owner. It does the work on its own machine and replies in seconds to a few minutes. Returns a reply_cursor. Tell the owner it's sent BEFORE you go looking for a reply, then check_agent_replies — and if nothing has landed by the end of your turn, watch_for_reply so the answer still reaches them. new_thread starts a fresh task thread instead of continuing the latest.

read_conversation

Scope: messaging:read

Read the recent messages in one of the owner's conversations (id from list_conversations). Works for direct chats and group chats. Summarize what was said in plain language — never paste a transcript back at the owner.

schedule_reminder

Scope: messaging:write

Come back LATER, once or on a repeat. Use it whenever they say 'remind me…', 'every morning…', 'check on this tomorrow', or ask for a recurring brief. Pass in_minutes for anything relative ('in 20 minutes') — it is exact. Pass run_at (ISO 8601) for a clock time, computed from the owner's local time and timezone, which you already know. prompt is the instruction to your future self, written in the second person: it is ALL the context that turn will have, so say what to do, not just the topic. Confirm back in their words and their local time, never a raw timestamp. This is ALSO how an agent gets ROUTINE WORK — 'have the agent check the inventory every weekday at 9' is this tool with a recurrence, and a prompt telling your future self to relay it: name the agent and say exactly what to ask, e.g. 'Send Marketing Assistant (agent_id abc…) this: check yesterday's orders and flag anything unshipped. Then watch_for_reply and bring the answer back.' There is no separate schedule that lives on the agent — you are the one who wakes and hands it the work.

send_message

Scope: messaging:write

Send a message as the owner in one of their conversations. To a PERSON this is drafted and queued for the owner's approval — they see the exact words on a card before it goes, so write the message as if it will be sent verbatim, and tell them you've queued it rather than that you sent it. To one of the owner's OWN agents it goes straight out (message_agent is the better tool there — it returns a reply cursor).

watch_for_reply

Scope: messaging:write

Keep listening for an agent's answer after this turn ends, and bring it back to the owner the moment it lands. Call it whenever you relayed work and check_agent_replies came back empty — that is the normal case, because agents take minutes and your turn takes seconds. Then tell the owner you'll come back with the answer and STOP; you will be woken. Never promise to follow up without setting this.

what_needs_attention

Scope: messaging:read

Everything waiting on the owner right now, ranked: actions queued for their approval, unread messages (split into agents that answered and people waiting), agents holding an open task on a machine that stopped responding, wallet trouble, and unread platform notifications. Use it for 'what needs my attention', 'anything I missed', 'what's waiting', and to open a morning brief. Read the urgency-1 items out first; if nothing is waiting, say exactly that rather than padding.

Phone

assign_phone_number_to_space

Scope: phone:write

Assign one of the account's existing phone numbers to a space.

build_sms_signup_pages

Scope: phone:write

Build (or refresh) the three public pages carriers open for a texting campaign, in one of the owner's spaces: a SIGN-UP page with a real Wakato form (name, mobile, optional email, an unticked SMS box with the full disclosure — sign-ups become contacts with their agreement recorded), a PRIVACY POLICY (numbers never shared) and SMS TERMS (program, frequency, rates, STOP/HELP). Published on the space's own domain when one is connected and ready (/sms, /sms/privacy, /sms/terms), else on Wakato's pages address. Points the campaign draft at them and runs the live check. Building again updates the same pages. space_id: defaults to the space the owner's US numbers are in (or their only space); ask if it says it needs one.

create_sms_consent_page

Scope: phone:write

OLDER, text-only consent page — prefer build_sms_signup_pages, which makes a real sign-up form plus the privacy policy and terms carriers ask for. Create (or refresh) a public hosted SMS consent/opt-in page for a campaign draft and set it as the draft's consent_url. Carriers verify this URL anonymously. The consent_text must state: the brand name, what messages subscribers get and how often, 'Message and data rates may apply', 'Reply STOP to cancel, HELP for help', and that consent is not shared with third parties. space_id decides which space hosts the page — ask the owner if unsure; do not guess.

delete_10dlc_draft

Scope: phone:write

Delete a 10DLC brand or campaign DRAFT. Deleting a brand draft also deletes its campaign drafts. Registered brands/campaigns can only be deleted by the owner in the UI (that also deregisters them at Telnyx).

draft_10dlc_brand

Scope: phone:write

Step 1 of texting from US numbers: prepare the business registration (the 'brand') as a DRAFT. For businesses the legal name must match IRS records (CP-575) exactly; the 9-digit EIN is NOT passed here — the owner types it on the approval card when you submit (submit_10dlc_brand). Sole proprietors register under their own legal name with a mobile number that receives a PIN. Returns a compliance report — fix errors, then submit_10dlc_brand.

draft_10dlc_campaign

Scope: phone:write

Step 2 of texting from US numbers: prepare the campaign (what the business will text, to whom) as a DRAFT under a brand. ONE kind of message per campaign — don't mix reminders or offers into account alerts. Carriers reject vague campaigns: the description says concretely WHO receives texts, HOW they agree (the sign-up form), and WHAT they receive; samples name the business and match the use case; include 'Reply STOP to opt out'. Then build_sms_signup_pages, validate_10dlc_draft, submit_10dlc_campaign.

get_10dlc_status

Scope: phone:read

Full 10DLC SMS-compliance picture: brands, campaigns (drafts included), and which phone numbers can already send SMS. Pass sync=true to refresh pending brands/campaigns from the carrier registry first — use this to poll for approval instead of asking the owner to click Refresh. US numbers cannot send SMS until an approved brand + active campaign are linked to them.

link_number_to_campaign

Scope: phone:write

Link one of the account's phone numbers to an ACTIVE 10DLC campaign so it can send SMS. Free and reversible. Campaigns auto-link existing numbers on activation — use this for numbers bought later. Sole-proprietor campaigns allow 1 number.

list_phone_numbers

Scope: phone:read

List the account's phone numbers with billing status and space assignment.

purchase_phone_number

Scope: phone:write

Purchase a phone number from search results. Bills the account wallet monthly and counts against this key's spend limit. Optionally assigns it to a space. Available in US, CA, GB, AU only.

resend_10dlc_brand_pin

Scope: phone:write

Sole proprietors: send the verification PIN to the owner's mobile again.

search_available_phone_numbers

Scope: phone:read

Search local phone numbers available for purchase (number, region, monthly cost). Wakato sells numbers in United States (US), Canada (CA), United Kingdom (GB), Australia (AU) only — any other country is refused, and the owner can request one from Backstage → Phone Numbers.

submit_10dlc_brand

Scope: phone:write

Send the business registration (brand) to US carriers. Waits on the owner's Allow card — that tap is their consent to $4/month from their wallet; for a business the owner types the EIN on the same card (you never see it). Checks the draft first and answers status 'not_ready' with what to fix instead of queuing. After Allow, call again with approved_action_id. Sole proprietors then get a PIN by text: verify_10dlc_brand_pin.

submit_10dlc_campaign

Scope: phone:write

Send a texting campaign to US carriers (the business must be approved). Runs the live check first and answers status 'not_ready' with the errors instead of queuing; otherwise puts an Allow card in the owner's chat — their consent to $10/month from their wallet. After Allow, call again with approved_action_id. Carriers decide in 1–3 business days; the owner (and you, in this chat) are told when they do, and their US numbers link themselves on approval.

update_10dlc_brand_draft

Scope: phone:write

Update a 10DLC brand DRAFT (only rows with status 'draft'). Send just the fields to change. Returns the updated draft plus a fresh compliance report.

update_10dlc_campaign_draft

Scope: phone:write

Update a 10DLC campaign DRAFT (only rows with status 'draft'). Send just the fields to change. Returns the updated draft plus a fresh compliance report.

validate_10dlc_draft

Scope: phone:read

Check a draft the way a carrier reviewer would. Campaigns: samples name the business, one kind of message, STOP/HELP, and it OPENS the business website, the sign-up page (real form, unticked box), the privacy policy and the terms — a page that doesn't load is an error. Loop draft → validate → fix until it passes, then submit. Tell the owner plainly what only they can fix (e.g. their website being down).

verify_10dlc_brand_pin

Scope: phone:write

Sole proprietors: confirm the PIN carriers texted to the owner's mobile after submit_10dlc_brand. Ask the owner to read it to you.

Professional Email

assign_email_address_to_space

Scope: email:write

Assign one of the account's email addresses to a space so its surfaces can send from it.

create_email_address

Scope: email:write

Create a professional email address (e.g. hello@yourdomain.com) on an email-enabled domain. REQUIRES OWNER APPROVAL (two-call flow). New addresses always require send approval in Agent Mail.

enable_email_on_domain

Scope: email:write

Make one of the account's domains email-ready (Agent Mail): registers it for sending/receiving and auto-writes MX/SPF/DKIM DNS. REQUIRES OWNER APPROVAL (two-call flow). Domains bought through purchase_domain are already email-ready.

list_email_addresses

Scope: email:read

List the account's professional email addresses (Agent Mail identities) with their domain and space assignments.

unassign_email_address_from_space

Scope: email:write

Remove an email address's assignment to a space.

Profiles

create_business_account

Scope: profiles:write

Create a DRAFT business account and fill whatever details you have — the owner completes verification afterward. This does NOT verify the business, accept any agreement, or enable payments: it only saves the business record (identity-light prefill). Verifying the business, accepting the verification agreement, and the sensitive identity/ownership checks are the OWNER's step at /settings/account-details/business/:id ('Create & Verify Business Account') — the agent cannot do it. Only profile_name is required; add everything else you know and leave the rest for the owner. Sensitive verification details (date of birth, government id, id documents) are never stored here — they're collected directly during verification. Returns the account_id and what's still missing before verification.

create_profile_post

Scope: profiles:write

Publish a post to a profile's Posts feed (the owner's wall). Needs body text and/or media. media = [{ url, type:'image'|'video' }]. Add the 'posts' tab (set_profile_tabs) so visitors see the feed.

create_wakato_profile

Scope: profiles:write

Create a Wakato Profile on one of the account's accounts. Defaults to the personal (admin) account; pass account_type 'business' + account_id (from list_profile_accounts) for a business profile. Starts with the default content tabs (personal: About, Resources; business also gets Products, Reviews). The account's FIRST profile automatically becomes its primary. New profiles start PRIVATE — fill in the content first, then publish deliberately with update_wakato_profile is_public:true (or pass is_public:true here if the owner asked for it live immediately). Returns the profile id and public URL.

delete_profile_post

Scope: profiles:write

Delete a post from a profile's feed.

delete_wakato_profile

Scope: profiles:write

Permanently delete a Wakato Profile (and its posts + storefront links). If it was the account's primary and other profiles remain, the newest survivor is promoted to primary automatically.

get_business_details

Scope: profiles:read

Read a business account's full details — legal/tax info, addresses, the primary representative, additional owners — plus its verification status (verified? submitted? can it get paid?) and, when not yet verified, exactly which required fields are still missing. Use this to see what's filled and what to add before the owner verifies. account_id from list_profile_accounts.

get_wakato_profile

Scope: profiles:read

Get one Wakato Profile in full: name, description, video, theme, public/primary state, custom domain, its content tabs (read-modify-write these with set_profile_tabs), and curated storefront product ids. Use before editing.

list_agents_with_reach

Scope: profiles:read

The owner's agents that have a Reach (id = the Reach row, name, space, status, public_token) — the pool whose widget you can embed in a profile's 'agent' tab (set_profile_tabs → reachId = that id + reachToken = public_token). An agent with no Reach yet is not here: switch one on with space_enable_agent_reach first.

list_my_products

Scope: profiles:read

List the account's own commerce listings (id, title, price, status) — the pool you can curate onto a business profile's storefront with set_profile_products. Product/Review CONTENT itself always comes from commerce; this is just for choosing which listings a profile features.

list_profile_accounts

Scope: profiles:read

List the accounts a Wakato Profile can be attached to: the one personal (admin) account plus any business accounts, each with its id, name, and @username. Start here — create_wakato_profile needs a business account id (personal defaults automatically).

list_profile_followers

Scope: profiles:read

List an account's followers (people/businesses following it). account_type 'admin' (personal) or 'business' + account_id from list_profile_accounts.

list_profile_following

Scope: profiles:read

List the accounts an account is following. account_type 'admin'/'business' + account_id from list_profile_accounts.

list_profile_papers

Scope: profiles:read

Every paper on a Wakato Profile — the long-form writing behind a 'papers' tab — drafts included. Pass status:'published' for only what visitors can see. Papers belong to the PROFILE and render on its page; they are not space blog posts and never appear in a space's blog tools.

list_profile_posts

Scope: profiles:read

List posts on a profile's Posts feed (most recent first, pinned on top).

list_wakato_profiles

Scope: profiles:read

List all of the account's public Wakato Profiles (the /profile/:username pages) with their public URL, whether each is public and the account's primary, video/tab presence, and view count.

set_primary_profile

Scope: profiles:write

Make a profile the account's primary — the one the bare @username URL (/profile/:username) resolves to. Only one profile per account is primary at a time (this unsets any other). Bare-@username resolution applies to the personal account; business profiles are always addressed by their full URL.

set_profile_products

Scope: profiles:write

Choose exactly which of the account's listings appear on a BUSINESS profile's storefront (Products tab). Pass the full set of product_ids (from list_my_products) — this replaces the current selection; an empty array clears it. Only business/seller profiles have a storefront.

set_profile_tabs

Scope: profiles:write

Replace a profile's content tabs (read the current set with get_wakato_profile first, then send the full new array). Each tab = { id, label, type, isDefault?, ...type fields }. Types: 'about' (the profile's rich-text intro — edit the text itself with update_wakato_profile about_html), 'resources' (resources: [{ id?,title,description,thumbnailUrl,linkUrl,group?,ctaLabel? }] plus layout: 'list' for a plain link list (label it Links) or 'cards' for picture cards, default 'cards'. group is the card's TYPE — 'Guides', 'Templates', 'Talks' — drawn as filter chips across the top of the tab; reuse the same word on every card of that kind, and a new word IS a new type), 'posts' (the profile's own feed, written with create_profile_post; add postsLayout: 'grid' to show it as a photo/video grid instead — label that one Media — or 'feed', the default; post types are automatic from the post's shape), 'papers' (long-form writing; CONTENT is written with write_profile_paper, whose category is the paper's type chip), 'calendar' (bookingPageId — ONE active booking page per tab; visitors book through /b/<slug>), 'events', 'apps' (published agentic apps: [{ share_token, allow_copy?, snapshot_share_token?, type? }] — carry the entries through as read; type ('Tools', 'Games'…) is the one field you may set, it becomes a filter chip), 'products' & 'reviews' (business-only; CONTENT is pulled from commerce — you only choose whether the tab shows), 'agent' (business-only; reachId — embeds an agent's Reach widget; ids from list_agents_with_reach). Products/Reviews/Agent tabs are ignored on personal profiles. An About tab is always kept. A TAB IS A CONTAINER, NOT CONTENT — only add one you are also going to fill, and only promise what exists. A card titled "Setup guide" must link to a setup guide: upload the file, or write it as a Page and link /pg/<slug>. Those open INSIDE the profile; an ordinary web address is a link and navigates away, so pointing several cards at one landing page gives the visitor several names for the same click. The result carries a review field saying which cards leave and which tabs are empty — read it.

update_account_identity

Scope: profiles:write

Edit the account HEADER identity that a profile shows but which lives on the ACCOUNT, not the profile row: @username, avatar, name/contact. account_type 'admin' (personal — display_name/first_name/last_name/avatar_url/bio/username/preferred_language) or 'business' (needs account_id from list_profile_accounts — profile_name/description/avatar_url/contact_email/contact_phone/website_url/industry/tagline/socials/username). username = 3–30 chars [a-z0-9_], globally unique.

update_business_details

Scope: profiles:write

Fill in or correct a DRAFT business account's details on an existing account_id (from list_profile_accounts). Send only the fields you're changing — partial updates are fine, so add what you have now and the owner can add the rest later. Same identity-light scope as create_business_account: this NEVER verifies the business, accepts the verification agreement, or enables payments — verification stays the owner's step. Passing owners replaces the whole additional-owners list. Returns which required fields are still missing before verification.

update_profile_paper

Scope: profiles:write

Edit or publish an existing paper on a Wakato Profile. Send only what changes; status:'published' puts it on the page, status:'draft' takes it back off. Paper ids from list_profile_papers.

update_profile_post

Scope: profiles:write

Edit a post on a profile's feed (body, media, link, or pin state). Send only what changes.

update_wakato_profile

Scope: profiles:write

Edit a Wakato Profile's fields — including about_html (the About tab's rich-text body) and socials (flat { platform: url } map; null clears it). Send only what changes. Setting is_public true/false publishes/unpublishes the page (no approval needed). custom_domain points the profile at a domain you control (pass null to clear) — DNS for the domain is managed separately.

write_profile_paper

Scope: profiles:write

Write a paper on a Wakato Profile — the guide, playbook or article a 'papers' tab exists to hold. This is the ONLY way to fill that tab: a papers tab with nothing in it is an empty room on a live page. body_html is REAL HTML ("<p>…</p>"), never HTML-escaped text. Defaults to a draft; pass status:'published' to put it on the page. The profile's papers collection is created on the first write.

Secrets

assign_secret_to_space

Scope: secrets:write

Give a space access to one of the account's secrets (its agents can then reference it via use_secret without seeing the value). REQUIRES OWNER APPROVAL (two-call flow).

create_secret

Scope: secrets:write

Store a secret (API key, login, token...) encrypted in the account vault. The value goes straight to encrypted storage and cannot be read back through account tools. Executes immediately (creation exposes nothing); sharing it with a space via assign_secret_to_space is what requires owner approval.

list_secrets

Scope: secrets:read

List the account's secrets (name, type, masked summary, space assignments). Values are NEVER readable through account tools.

request_secret_input

Scope: secrets:write

PREFERRED way to capture any sensitive value the owner must provide (API key, password, token, private key…). Opens a secure paste box pinned in this PM chat: the owner types the value straight into it and it goes directly to encrypted storage — you NEVER see the value, and it never appears in the chat. You only describe the SHAPE (name + which fields to collect); pass NO values. To rotate an existing secret, pass its secret_id (its type is kept). Use this instead of asking the owner to paste a secret into the chat for create_secret.

unassign_secret_from_space

Scope: secrets:write

Revoke a space's access to a secret.

Space API Keys

create_space_api_key

Scope: space_keys:write

Mint a scoped Space API key (wks_live_*) for a space this key may manage. The token is returned ONCE — use it against space-mcp / space-api for in-space work (contacts, tables, pages, automations...). Scope categories: ai, contacts, tables, pages, automations, forms, agent_mail, calendar, tasks, assets, social, messaging, documents, whiteboards, meet, phone, ads, agent_reach (= the agents' Reach settings — the category keeps its old key), finance, integrations, secrets, wallet, apps. A minted key can never out-rank the key minting it: with space_tools: write you may grant any action; with space_tools: read only read scopes are granted (the rest come back in clamped_scopes); with no space_tools at all, minting is refused.

list_space_api_keys

Scope: space_keys:read

List a space's API keys (metadata only — tokens are never retrievable).

revoke_space_api_key

Scope: space_keys:write

Revoke a space API key. Immediate and irreversible.

Space Passthrough

list_marketplace_categories

Scope: space_tools:read

The Wakato Marketplace's categories (id, name, parent). Set a listing's with space_update_product { marketplace_category_id }.

list_pending_approvals

Scope: space_tools:read

List this agent's queued outbound actions and their approval status.

Spaces

claim_space_release

Scope: spaces:write

Claim a PURCHASED space template into the account's templates (entitlement-checked). Returns the claimed template with its typed public_id (snap_space_*) — then use create_space_from_snapshot to build the space. App template releases don't need claiming — install_snapshot takes release_id directly.

connect_commerce_to_space

Scope: spaces:write

Put one of the owner's commerce accounts (shops) on a space. A shop is RUN FROM one space, its home ('Belongs to': its buyers become that space's contacts, its inbox, jobs and automations live there, its owner/admins and agent work it) and SOLD ON others ('Sells on': its live products on their pages, nothing else). By default this adds a placement — the products on that space's pages. Pass as_home: true to MOVE the desk there instead (what the old home's contacts already hold stays there). One shop per space either way. The owner may have several shops: pass seller_id to pick one (from space_get_commerce_status / list tools), else their oldest approved shop is meant. REQUIRES OWNER APPROVAL: the first call queues it and the owner gets an Approve/Reject card in chat; after they approve, call again with approved_action_id to execute. Only the shop's owner can do this, and only into a space they own or admin. Payouts and payment settings never move — they stay with the owner.

create_snapshot

Scope: spaces:write

Make an APP TEMPLATE from a Space App in a managed space (Backstage → Templates). Captures config/code — channels, secrets and conversations stay behind (they become install-time requirements); the app's records come along only with include_records / record_ids. Returns the template with its typed public_id (snap_app_*) — addable anywhere with install_snapshot. kind 'agent' is refused: an agent's template is its recipe.

create_space

Scope: spaces:write

Create a new space owned by the account, SET UP in the same call the way the New space screen does: a budget (optionally renewing every week or month, with caps), which AI models and services it may use (all, one of the owner's lists, or picked), the connected accounts, domain and Agent Mail mailboxes it uses. Call get_space_setup_options first and offer the owner what they actually have — ask how much budget and whether it renews; never invent ids. Without a budget the space starts at $0 and its agents can't think until money is allocated. The answer's setup says what was set and what wasn't (problems, in words). Spaces created by this key are always manageable by it, even under a space allowlist. For a PUBLIC agent do not make a space here — create_agent with kind 'public' makes its own.

create_space_from_snapshot

Scope: spaces:write

Start a NEW space from a space template id (yours or one claimed from a purchased release) — lands its pages, forms, documents, tables with their views, contact views, projects and tasks (nobody assigned), automations, booking pages, message templates, Space Apps, blog, files and their folders, mail templates + signatures, email/SMS/call campaigns (as sender-less DRAFTS), call scripts, audiences, calendar events, business research, chart of accounts, tags and contacts with fresh ids. Its AGENTS come back as agent templates (recipes) in agents — none is woken; set one up with create_agent (recipe) when the owner wants it. Then returns a READINESS report: missing AI models are auto-enabled and owned secrets auto-assigned; readiness.missing lists what still needs setup. notes says what could not land. Restored apps hold the capabilities they declare. Secret values, sending identity, live channels and message history never travel in templates.

find_in_app

Scope: spaces:read

Find the exact screen for what the owner names — a chat, a thread, an agent and its tabs, a space and its pages, a table, a document, a Backstage tab — and return its app path. Call it BEFORE opening anything; never invent paths. Pass their words as they said them ("the LinkedIn thread with SCO", "scoENERGY's memory", "the Leads table in Acme", "my Browsers"). Results come best first as { kind, label, where, path }; open one with open_screen (in chat) or navigate_app (on a call), and when two fit equally, ask which.

find_kept

Scope: spaces:read

What the owner KEPT in Wakato (More → Kept): videos, links, places, notes and Network posts they saved, newest first. Use it for 'the YouTube link I saved on December 5', 'that article about pricing I kept'. Search by words (query), by the day they kept it (on / from / to, YYYY-MM-DD, their timezone), by kind (video | link | place | note | post) or by list name. Each item has its title, url, note and when it was kept — open the link yourself if you need what is in it.

get_memory

Scope: spaces:read

Read your ACCOUNT-LEVEL memory vault — About you (the profile block), the index (every note's hook line) plus pinned notes, exactly what every one of your sessions starts with (system prompt on the platform runtime, CLAUDE.md on an Account Computer). Memory is a vault of small typed notes — the ONLY context that survives across threads (each PM thread is a fresh session). The profile blocks (About you / About itself), the index (every note's hook line) and the pinned notes load every session; fetch the rest with search_memory (words AND meaning) → read_memory_notes. WRITE RULES: search before writing; update the existing note (same slug) instead of creating a near-duplicate; save durable knowledge — decisions, preferences, people, project state, gotchas — never chit-chat and never data you can read live from platform tools (reference the entity instead, e.g. [[contact:UUID]]). When a fact changes, update the note or mark it superseded; link related notes with [[slug]]. Keep hooks tight — they ARE the index. Keep your profile block current: write slug profile-self (who you are here, how you work, the standing rules) with just a body — a few sentences, only what is always true. What you learn about a person is a person note named after them.

get_my_note

Scope: spaces:read

Read one of the owner's notes whole: the summary, what was said, the questions (who asked, the answer), the to-dos and the full transcript by speaker. transcript:false leaves the transcript out. Its link opens it in the app.

get_space

Scope: spaces:read

Get a space's details, budget, and member count.

get_space_setup_options

Scope: spaces:read

What the owner can give a space when making or setting one up: their model lists and service lists (with how many in each), connected accounts (apps, social, ads, bank — kind + id + name), domains, Agent Mail mailboxes, and wallet_free — how much of their wallet is not yet in any space. Read it before create_space / set_up_space and offer only what is there.

install_snapshot

Scope: spaces:write

Add an app template into a space and get a readiness report. Missing models are auto-enabled and owned secrets matching by name auto-assigned; the report's missing array lists what still needs the owner — resolve secrets with request_secret_input/assign_secret_to_space and connect integrations. Templates never carry secret values, channels, or data.

list_my_notes

Scope: spaces:read

List the owner's notes from the Note taker — meetings, talks and conversations they recorded on their phone, written up with who said what (title, when, how long, who spoke, the summary, which spaces they are shared with). Use it for 'the notes from…', 'what did X say at…', 'the meeting on Tuesday'. query narrows by words in the title or summary. Recording itself happens on the phone: on a call use take_notes; otherwise tell them More → Note taker in the app.

list_snapshots

Scope: spaces:read

List the APP TEMPLATES (Backstage → Templates) that can be added into a space — the account's own plus any shared into that space. Each entry reports dependency_count and whether it came from_this_space. Omit space_id to list them all. (Agent templates are recipes — list_agent_recipes / create_agent; an old 'agent' entry can no longer be added.)

list_space_snapshots

Scope: spaces:read

List the account's SPACE TEMPLATES (people see them under Backstage → Templates; structure + contents: pages, tables and their views, automations, apps, agents as recipes, projects, contacts...), including templates claimed from purchased releases. Use create_space_from_snapshot with an id to start a new space from one.

list_spaces

Scope: spaces:read

List the spaces this key may manage, each with its budget (allocated / spent / remaining).

memory_maintenance

Scope: spaces:read

Check the memory vault's health: how full the index and pins are against the budgets that block writes, which notes have gone stale, and which pairs look like near-duplicates. MERGING IS YOUR CALL, not the platform's: read both notes of a pair, and if they say the same thing, write the better-worded one (same slug) with the merged content and mark the other superseded (status='superseded', superseded_by_slug=the survivor) — never delete knowledge, and never merge two notes that only look alike. Do this when the nudge appears in memory, or when the owner asks you to tidy memory.

open_commerce_account_for_space

Scope: spaces:write

Open a NEW commerce account (a shop) for a space the owner OWNS, when that space has no shop yet: a shop named after the space (or name) is created in the owner's own account and RUN FROM that space (its home: buyers become the space's contacts, the inbox, jobs and automations live there), so the space's members and agents can build its catalog. REQUIRES OWNER APPROVAL: the first call queues it and the owner gets an Approve/Reject card in chat; after they approve, call again with approved_action_id to execute. The new shop cannot collect money until the owner chooses which verified business it pays out through (Account Management → Commerce accounts → Pays out through) — say that plainly. Use connect_commerce_to_space instead when the owner already has a shop they want to run from that space. Never name the underlying payment provider.

read_memory_notes

Scope: spaces:read

Load full memory notes by slug (max 8), with backlinks — which other notes reference each one. Follow [[slug]] links you find in bodies with another call.

recall_conversations

Scope: spaces:read

Remember what HAPPENED, and when — your past conversations with the owner, searched by meaning and by time: "what did we decide about the pricing page last week". Returns episodes (the reflection pass's summaries of past threads, with their period) and the messages that match the words. The chat is the record: cite the date, and offer to open the thread. Notes are what you KNOW; this is what happened.

search_memory

Scope: spaces:read

Search your account memory vault by WORDS and by MEANING ("the guy from the coffee shop" finds Marc). Returns matching notes' index lines (slug, title, type, hook, via) — load full bodies with read_memory_notes. Memory is a vault of small typed notes — the ONLY context that survives across threads (each PM thread is a fresh session). The profile blocks (About you / About itself), the index (every note's hook line) and the pinned notes load every session; fetch the rest with search_memory (words AND meaning) → read_memory_notes. WRITE RULES: search before writing; update the existing note (same slug) instead of creating a near-duplicate; save durable knowledge — decisions, preferences, people, project state, gotchas — never chit-chat and never data you can read live from platform tools (reference the entity instead, e.g. [[contact:UUID]]). When a fact changes, update the note or mark it superseded; link related notes with [[slug]]. Keep hooks tight — they ARE the index. Keep your profile block current: write slug profile-self (who you are here, how you work, the standing rules) with just a body — a few sentences, only what is always true. What you learn about a person is a person note named after them.

set_up_space

Scope: spaces:write

Give an EXISTING space the same setup create_space takes — a budget (once or renewing weekly/monthly, caps), models, services, connected accounts, a domain, mailboxes. Use it right after create_space_from_snapshot, for a public agent's own space after create_agent, or whenever the owner asks to wire things into a space. Adds; it never removes what the space already has (a models/services pick narrows a space that allowed everything). Answers what was set and what wasn't, in words.

update_memory

Scope: spaces:write

DEPRECATED single-doc memory writer — use write_memory_note. Only mode=append still works (it creates a note).

update_space

Scope: spaces:write

Update a space's name, description, icon, or color.

write_memory_note

Scope: spaces:write

Create or update ONE memory note (upsert by slug — reuse the slug to update, never create near-duplicates; search_memory first). Memory is a vault of small typed notes — the ONLY context that survives across threads (each PM thread is a fresh session). The profile blocks (About you / About itself), the index (every note's hook line) and the pinned notes load every session; fetch the rest with search_memory (words AND meaning) → read_memory_notes. WRITE RULES: search before writing; update the existing note (same slug) instead of creating a near-duplicate; save durable knowledge — decisions, preferences, people, project state, gotchas — never chit-chat and never data you can read live from platform tools (reference the entity instead, e.g. [[contact:UUID]]). When a fact changes, update the note or mark it superseded; link related notes with [[slug]]. Keep hooks tight — they ARE the index. Keep your profile block current: write slug profile-self (who you are here, how you work, the standing rules) with just a body — a few sentences, only what is always true. What you learn about a person is a person note named after them. Every change is versioned per note — the owner can review and roll back.