Keiki MCP server for AI agents and assistants

Stop a job started by a long call, and ask the work behind it to stop too.

Read a job that a long call handed back instead of a result: its status, the text and tool calls it has produced so far, and its final result once it has finished.

Who this token acts as, which organization it is bound to, and the current time.

Delete an agent group, so its members can no longer ask each other through it.

Delete an agent with its tools, alerts, loops and configuration, releasing its Keiki VM if it has one.

Uninstall a capability from an agent, dropping its version pin.

Remove sender identity checks; returns { ok }.

Remove a phone line from an agent; the agent stops receiving on it.

Delete one of the agent’s scheduled loops for good: its schedule stops and its run history is removed.

Disconnect an MCP preset from the agent and remove it from its daemon.

Delete an authored tool.

Revoke a purchase: cancels its payment credential so it can no longer be charged, and returns the updated purchase.

Unblock one identity for this conversation’s agent so its messages trigger replies again.

Clear the dynamic contact card for this conversation.

Permanently delete one agent’s stored message history with an identity and return how many messages were cleared.

End a human takeover early and hand the conversation back to the agent, including any hold taken from a Slack thread.

Delete one deployment and release its connected channels.

Delete an organization eval case permanently, not just archive it.

Delete an identity: tears down its inbound routing and deactivates it, so the channel stops answering.

Stop answering in one workspace that installed this Slack identity, without touching the app or its other workspaces — the workspace keeps the app in Slack; only its stored token is dropped.

Remove one Slack user from a Slack identity’s operator allowlist.

Stop routing one customer Slack workspace to its agent.

Forget one tenant’s install of a Teams identity so the agent stops answering there.

Revoke a pending invitation so its link no longer works.

Revoke this user’s organization OAuth connection; returns { ok }.

Remove a member from the organization.

Stop sharing an org MCP integration, removing it from every agent it was granted to.

Disconnect payments; returns { ok }.

Delete a payee; returns { ok }.

Disconnect one of the organization’s own Photon accounts.

Delete a sandbox script; agents it is attached to stop running it.

Delete a secret and its bound mirrors; returns { ok, name }.

Delete a skill or document; agents using it lose it.

Disable SSO; returns { ok }.

Remove an SSO domain; returns { ok }.

Delete a destination and its agent attachments.

Delete a webhook endpoint.

Create or update an agent deployment using the body format of POST /api/v1/developer/deployments.

File a bug report or feature request about the Keiki platform itself with the engineering team.

The outcome kinds each agent has produced and whether any carry money — what an agent’s CRM columns stand for.

List the organization’s agent groups — which agents may ask each other with ask_agent — with each group’s name, description and members (agent, description, hub or spoke role).

Every agent group’s running peer threads and live roster in one read — the way to answer how all the groups (swarms) are doing at once.

The group’s shared note — what its agents have settled among themselves (decisions, who does what, findings) — with its revision, last author and update time.

History of the group note, newest first: one entry per saved version, with the sha to fetch it by.

The group note body as it was at one historical version (a sha from the versions list).

Live roster of one group: per member its status (running, waiting, idle, ended), running turns, pending asks, background tasks and 24h tokens and cost, plus totals.

The asker→peer threads currently live among one group’s members (who is asking whom right now).

Custom email domains the organization added for agent inboxes, each with its region and live DNS verification state from AgentMail.

List every agent in the organization with its status, model and channels.

Whether other vendors’ agents can call the agent over A2A, with its Agent Card URL and JSON-RPC endpoint.

List the agent’s persisted approval actions (tool calls waiting on, or past, a human decision), newest first, with their status, arguments and group id.

Engagement for one agent over a date range: contact and agent response times, received/sent message breakdowns such as where contacts write from (null when event analytics is not configured), and public profile visits.

Whether the agent answers on the OpenAI/Anthropic-compatible API and in passthrough mode, with the base URLs and the model name a client sends.

Agent detail: its configuration and features, line routing status, harness, template version, tools, attached skills, its 50 most recent conversations, and connection issues to fix.

List the marketplace capabilities installed on an agent, including disabled ones, with each pinned version, how it was installed, any newer version available, and declared secrets the org has not set yet.

Every conversation one agent is having, newest first — who it is talking to, the last message, message count, whether the thread is active and whether it has errors.

One conversation thread between the agent and a contact (`phone` is their phone number, email or tg: identity, URL-encoded): its metadata, messages and the trace spans of the turns that produced them.

One conversation’s mood per user turn, oldest first (0 angry to 4 delighted; unclassified turns have no score), with drop/recovery shifts, the reply that caused each shift and why, and the signals on each turn.

The agent form payload: the full editable config (name, model, systemPrompt, features, escalationRoutes, skillIds, sandboxScriptIds, sandboxEnvSecrets, execPolicy, userSecrets, responseSchemaOverlay, updatedAt) plus the org’s lines.

Preview a real-channel eval run per hosted driver (imessage, email, x): whether it is available and why not, the handle it would message, and the eligible and excluded cases — plus any active run and the last run.

Resolve the agent’s Executor.

Read fine-tune readiness for the agent’s current version: graded conversation counts, progress toward the kickoff threshold, whether the caller may start one, and any request already on file.

Report what runs the agent and whether it is connected: the platform harness, a self-hosted Hermes relay or dispatch URL (with why it is waiting), or a Maritime Keiki VM and its state.

List the scheduled loops attached to an agent with their schedule and state.

Read a loop’s recent runs, newest first, from a bounded retention window: status (the platform’s turn and tool-health view), timings, error, trace id and detail.

The tools a connected MCP exposes, read live from the daemon, each with the permission (allow/ask/deny) in force, plus the default permission and every stored per-tool choice.

Read the agent’s working note — the durable scratchpad it rewrites while it works — with its revision.

List the working note’s version history, newest first, with the sha of each version.

Read the working note body as it was at one version sha from the history.

Whether the agent’s public profile page is published, its URL slug and tagline, and whether the caller may change it.

Turn-quality review for one agent: review stats, its review settings, and the prompt or model fixes the reviewer drafted (state, summary, rationale, proposed prompt/model, score before and after).

Read the agent’s open staged rollout (mode, percent of conversations on the staged config, the staged config itself) and its recent ended rollouts.

The latest 50 runs of the agent’s sandbox scripts, newest first — status, exit code and output tails.

The shared iMessage number and join code contacts text to reach this agent.

Built-in quality signals for one agent over a date range: each signal’s events, share of classified users and change against the previous period of the same length, plus average mood (0 angry to 4 delighted) and the biggest mood drops with the judge’s reason.

The turns one signal (`key`, as returned by the signals summary) fired on, newest first: phone, trace id, source, mood and shift.

List the personal provider definitions declared on the agent — services each conversation user authorizes with their own account.

List the agent configuration’s version history, with the sha of each version.

Read the agent configuration snapshot saved at one version sha.

The agent’s wallet: spending policy, connection state, spend so far, pending purchase approvals and history — or null when it has none — plus the payment programme, default policy, and whether the caller may manage it.

Labelled payment methods on the wallet’s connected account (never card numbers), for choosing `paymentMethodId`.

Complete agent templates the platform can provision in one call (e.

List audit events as { events, nextCursor }; filter by cursor, limit, actor, action, target_type, target_id, from, to.

Verify the organization audit hash chain and return its verification result.

Read whether the organization’s plan allows Auto mode and which front and worker models it uses.

Spans read from the OTLP collector — kept past the 14-day window of /traces, and alongside spans other services exported under the same trace.

Read the organization’s billing overview: available phone lines, usage, customer plan details, upcoming invoice and default plan id.

List the organization’s invoice and platform credit grant activity, newest first.

Read the organization’s auto top-up settings: enabled, threshold, quantity, whether it is available on the plan, whether a payment method is saved, and the last failed top-up if any.

Read the default plan’s per-capability billing metadata, included amounts, units and price labels.

Read local capability usage grouped by feature and agent for each feature’s latest recorded billing period, including unattributed and deleted-agent buckets.

Read public consumer plans, add-ons and feature pricing metadata from the billing catalog.

Read public default-plan included token-credit allowances without customer data.

List the organization’s available non-add-on, non-archived plans with display prices, features, trial information and current/scheduled flags.

Create a Stripe billing portal link for the organization.

Read the connected organization’s current plan and status, usage and credit access checks.

Read public recurring plans with included limits and platform credit conversion rates for comparing options.

Read the organization’s recorded customer service charges for the billing period.

Check the organization’s lightweight plan gate rather than loading its billing overview.

List up to 100 conversations with the most recorded token usage across the organization’s active developer configurations, excluding playground and copilot traffic.

Keiki's own blog, newest first: each post's slug, title, category (Changelog, Product, Announcements), publish date, summary and URL.

One Keiki blog post in full: its title, category, date and summary, plus the whole post as `markdown`.

Every platform capability offered on this deployment and the tools each adds to an agent that enables it, as feature, tool name and tool description.

List organization early-access requests as { requests }.

One page of the organization’s conversations, most recent first, each with its agent, identity and latest state; with q, a full-text search of message content returning matching conversations with snippets.

One conversation thread by identity (phone number, email, or prefixed id like tg:123): its messages with their trace spans, the agent, blocked and takeover state, whether a turn is running, background tasks, and the peer for inter-agent threads.

Read the contact card set specifically for this conversation, and whether dynamic contact cards are available.

How many conversations match the same filters as the conversation list, and how many of those need a person: { all, needsReview }.

Home-page summary for the signed-in user: their name, email, role and orgs (with the active one), headline stats (active conversations, messages today, average response time, total turns) and every agent in the org.

Read one deployment in the current organization.

List the organization agent’s persisted eval cases, including generated, user-authored and regression cases.

Read the generated eval suite’s version history for an agent in the organization.

Compare two organization eval runs as their results arrive.

Read one organization eval run’s status, candidates, rankings and per-case results with trace ids.

Read the full persisted case records referenced by an organization eval run, including archived cases.

Read the agent’s latest eval run, optionally limited to single-model, sweep or real-channel runs.

Read an organization real-channel eval run’s recorded message transcript.

Find behaviors worth testing from the agent’s recorded production traffic in the chosen window, with trace counts, error rates, models and existing suite coverage.

List the org’s active messaging identities — SMS lines, Telegram, WhatsApp, Slack, Teams, X and AgentMail — with the agent each is attached to and its routing status.

List the agent's iMessage lines and whether each can forward its calls: `{ lines: [{ number, support, connected }] }`.

Search Telnyx for available US local voice numbers in an area code or state, or anywhere in the US when neither is given.

List the ElevenLabs voices a phone line can use: `{ voices: [{ id, name, description, previewUrl, labels }] }`.

Per workspace that installed this Slack identity, the channels its bot is already in — the channel ids an escalation route may name — plus the scopes the install is missing, or an error when its token cannot list channels.

Build the Slack app manifest for a new identity and a prefilled api.

List the Slack users allowed to press this identity’s consequential buttons — taking a conversation over, replying to a customer, running an offered action.

Check a Slack signing-secret probe: pending until a signed event from Slack arrives, then proven or failed.

For a Slack app that routes customer workspaces to different agents, list each workspace: its team id, the bound agent (or null), whether the app is installed there, and when it was last messaged while unbound.

The Teams app manifest for a connected Teams identity — it names that identity’s Microsoft App ID.

Return the messaging endpoint an Azure Bot registration must point at before a Teams identity can be connected.

Read platform Kapso configuration as { available }.

Whether “Log in with X” can be offered — an X OAuth client is configured — plus which app-level credentials the platform already has, the redirect URI to register on the X app, and the hosted eval driver’s handle when one exists.

The redirect X sends the user back to after authorizing.

Poll a started X login: returns the authorization’s status and, once complete, the X account it resolved to — the input the connect call needs as `oauthState`.

Org analytics over a date range: daily activity, totals (messages, conversations, turns, errors, tokens, average latency), turns and messages per agent, task outcomes and response times.

List the organization’s invitations, newest first, with email, role, status (pending, accepted or revoked) and expiry.

List the organization’s API keys: name, prefix (never the full secret), scopes, bound agent, and last-used, expiry, revocation and creation times.

Daily usage of one API key, aggregated by day, by route and method, and by agent, with accepted vs rejected (revoked/expired) counts and first/last seen times.

List the organization’s phone lines with channel, line type, routing status and message, activation time, and the agent each is assigned to.

Read the contact card iMessage shows for a line — first and last name, photo URL, and whether the provider has applied it — straight from the line’s provider, plus the line’s channel.

The display price of a new iMessage line (`price`, e.

Status of each iMessage line provider (Photon, Linq, Blooio) as shown on the status page: today’s `state`, reachability, last check, 90-day uptime and daily history.

Progress of one of the organization’s line purchases: `status` (pending, provisioning, action_required, requested, completed or error), the `phoneNumber` once ready, the Blooio `actionUrl` when the purchase needs completing, or the `error`.

What the org’s agents are doing right now: the agents, turns from the last five minutes plus any still running with their steps, outcomes and new people from the last half hour, and today’s numbers.

List the organization’s scheduled loops, newest first: agent, the person it runs for, schedule, enabled and auto-paused state, last status and error, last and next run, and run count.

Browse published (reviewed) marketplace capabilities, one listing per capability with its newest version and the other versions available to pin, plus whether the caller is a capability reviewer.

List the capabilities this organization has published itself, in every review state (draft, pending review, published, rejected).

List the capabilities awaiting publication review.

Resolve the brand behind an MCP server endpoint URL — its name, domain, description and logo.

Search the approved integrations.

Resolve one catalogued domain into its connectable surfaces — MCP endpoints, OpenAPI/GraphQL specs and CLIs — with each surface’s URL, transports and the credential alternatives it needs.

List this user’s organization OAuth connections as { connections }.

List the members of the connected organization with their role and last sign-in, plus the caller’s own user id and role and whether the caller may manage members.

Search the models an agent can run on — ids, context window, price per million tokens, and tool, reasoning and vision support.

The signed-in user’s daily digest preference (`digestOptOut`) and the timezone the digest is sent in (null when none was reported).

List the organization-owned MCP integrations: endpoint, auth mode, header names (never values), which groups and agents each is granted to, and every materialised agent’s connection status and last error.

List every organization the signed-in user belongs to, with their role and logo in each, plus the id of the currently active organization.

Look up the brand logo URL for a domain.

Read the active organization’s id, name, logo domain and logo URL, and whether the caller may edit it (`canManage`).

Read the agent ideas Home shows for the active organization: up to three items (title, description, channel, prompt) the organization wrote itself, else generated from its saved website domain, else a generic set.

Recorded business outcomes — sales, bookings, qualified leads — newest first, with totals per kind for the same agent, person and time scope.

Read the organization’s Grosso payments account: connected, pending a signup code, or not connected; test or live; and whether Grosso still accepts its key.

Read the organization’s newest 100 Grosso payees (businesses it collects payments for): owner email, business name, status, whether it can be charged, and the one agent it belongs to (null when unassigned).

Directory of the people behind the organization’s conversations, most recently seen first, with the total matching count.

One person: their identities across channels, conversations, loops, connected accounts, and their confirmed outcome count and value.

List the organization’s own Photon accounts connected to Keiki: label, Photon project id, connection status (`active`, or `error` with a message when Keiki’s webhook or credentials stopped working) and the lines imported from each.

Read sandbox provider availability as { providers }.

List the org’s sandbox scripts with the agents running each and its newest run — where a script that fails every boot shows up.

Read one sandbox script, including its body, targets, timeout and env secret names.

Every sandbox run of one script across its agents, newest first — status, exit code and output tails.

Version history of a sandbox script, newest first — each entry carries the commit sha to read it at.

Read a sandbox script’s body as of one version, by the sha from its version history.

List the organization’s developer secret names with created/updated times and any host binding; values are never returned.

Built-in quality signals across every agent in the org, or one agent: events, share of classified users, change against the previous period, and average mood.

List the org’s skills and knowledge documents (metadata, no body) with the agents each is attached to.

Read one skill or document, including its full body.

List the built-in preset skills (id, capability, name, description, kind) and whether the org already added each.

Version history of a skill, newest first — each entry carries the commit sha to read it at.

Read a skill’s body and metadata as of one version, by the sha from its version history.

Read SSO connection, domains, eligibility and platform configuration.

List the destinations the org ships finished turns to — format, endpoint, header names (never values), enabled, attached agent ids, last delivery status — plus the formats available.

List one page of the org’s agent turns (traces), newest first, with status, model, tokens and error.

One turn with all its spans (every model step and tool call with full input/output).

Count the turns matching the same filters as /traces; returns { total }.

What one turn did, in a small response: the reply it sent, every tool call with clipped input/output, and the spans that errored.

Whether agent wallets are offered on this deployment: each payment provider with whether it is configured and in test mode, plus overall configured/available flags.

List 50 outgoing consent/test webhook deliveries in this org, newest first.

Read one org-owned outgoing delivery, its immutable event payload and the latest 100 attempts.

List the org’s webhook endpoints (id, name, url) — the targets an escalation route can post to.

One webhook endpoint: its name, url and the events it subscribes to.

List the agent templates available for deployments.

List the channel types and required deployment fields.

Patch a Telegram identity’s group-chat behaviour — only the fields sent change; omitted fields keep their stored value.

Set a phone line's voice: answering model, ElevenLabs voice and delivery, first message, language, turn-taking, persona and tone.

Change one member’s role, or their display name — one or the other per call.

Update the signed-in user’s daily digest settings; only the fields sent change.

Rename the active organization, change its logo domain, or upload a logo; only the fields sent change.

Set the fields an operator owns on a person, patching only those sent: displayName, primaryEmail, notes.

Update IdP metadata/configuration and defaultRole, enforce, activate; returns SSO settings.

Create an agent group, optionally with its members, and return its id.

Stop a whole group: end every live peer thread among its members and cancel their background tasks.

Add a custom email domain for agent inboxes.

Create an agent and return its id.

Turn the agent’s A2A endpoint and Agent Card on or off.

Approve (run) or decline one pending agent action and return the updated action; when its inputs changed since it was proposed it comes back superseded with what changed.

Approve or decline every pending action sharing a group id (from GET /agents/:id/actions), in order; approving stops at the first one that fails or is superseded.

Turn the agent’s OpenAI/Anthropic-compatible API on or off, and/or switch passthrough mode (the caller’s own prompt leads each turn) — send at least one.

Update an agent from its GET /agents/:id/edit config with your changes applied.

Install a marketplace capability version on an agent, or re-pin an installed one to another version.

Enable or disable an installed capability, keeping its pinned version.

Start a real-channel eval run in which a platform-owned identity messages the agent over a real channel; returns the run id (watch it at /watch/:runId), the target handle and the cases run or excluded.

Record a fine-tune request for the agent’s current version; refused until enough graded conversations exist.

Replace a Maritime agent’s Keiki VM with a fresh one built from the current runner and return the new VM status.

Rotate an external harness credential; returns { signingSecret }.

Give an agent another phone line.

Move a line this agent holds to another agent in one step.

Reset a loop: zero its run count and last status, delete its run history, and drop the snapshot it diffs against, so the next run starts fresh.

Pause or resume one of the agent’s scheduled loops.

Run one of the agent’s scheduled loops now, through the same pipeline as a scheduled run.

Connect (or reconnect) one MCP preset on the agent’s Executor daemon.

Share an agent’s MCP connection with the organization: its credential moves to an org-owned integration granted to the given groups and agents, then installed on each.

Re-check an MCP preset’s connection on the daemon without restarting OAuth — poll it after the user authorizes.

Tell the agent something in its own conversations and let it decide whether the people in them hear about it — how you notify everyone using an agent (an outage, a capability going away, a migration).

Apply a drafted fix to the agent’s live configuration (a new agent version).

Dismiss a drafted fix, together with the failure cluster it came from so the same symptom is not suggested again.

Change the agent’s turn-review settings.

Set the share of conversations an open rollout serves its staged config to, and resume it when paused.

Make the rollout’s staged config live for every conversation, recorded as a new version, and end the rollout.

End the rollout and send every conversation back to the live config.

Re-apply the agent’s own template, at the template’s current version, onto its configuration (e.

Save a new authored code tool as a disabled draft (saving under the name of an existing authored tool rewrites that draft).

Publish an authored tool to the agent so it can call it, or unpublish it with enabled false.

Roll the agent back to the configuration saved at a version sha, recorded as a new version whose sha is returned.

Buy usage credits for the organization; owners and admins only.

Attach the selected plan to the organization; owners and admins only.

Release an active phone line owned by the organization and unassign it from agents; owners and admins only.

Submit { channel, purpose, expectedVolume }; returns { request }.

Block one identity for this conversation’s agent, so its messages no longer trigger agent replies.

End an inter-agent (agent:) thread: settle its pending asks and refuse new ones until the identity is unblocked.

Send a message the contact reads as the agent’s, over the conversation’s own channel, and renew the takeover.

Run a turn on this conversation as if the contact had written the text, and return what the agent would answer with its trace id.

Hold one conversation for a human for 30 minutes: incoming messages are stored for them to answer and no agent turn runs.

Add a user-authored eval case to an agent in the organization and return the saved case.

Re-author and persist the agent’s generated eval suite from its current configuration, keeping user and regression cases and recording a suite version.

Start paid-plan evals comparing two different readable config versions of the organization’s agent against up to 12 existing cases.

Start a paid-plan eval run on the agent’s saved suite, or selected case ids including archived cases; generation occurs only if the saved suite is empty.

Request cooperative cancellation of an organization eval run that is still running; the runner checks between cases.

Create regression eval cases from selected production suggestions by replaying recorded conversation evidence in a mocked world, without model calls.

Create an AgentMail email identity attached to an agent — a new inbox on the managed domain or one of the org’s verified custom domains, or an existing inbox the org already owns — and register its inbound webhook.

Rotate an AgentMail identity’s inbox-scoped API key — mints a replacement, stores it, deletes the old key, and when attached re-registers the inbound webhook.

Verify an AgentMail identity: re-fetches the inbox, and when the identity is attached to an agent (re)registers the inbound webhook.

Route an identity to an agent: registers the channel’s inbound webhook or subscription and marks the identity routing-active.

Stop routing an identity to its agent: tears down the channel’s webhook or subscription and leaves the identity unattached, so inbound messages stop being answered.

Buy a voice number in the area code or state (or any US number when neither is given) and connect it to the agent for inbound phone calls (charges the org).

Ask the team to set up call forwarding by hand for an iMessage line whose provider cannot do it automatically.

Speak a short text (at most 300 characters; defaults to the first message) in a voice.

Create a Slack identity from a manually-built Slack app: bot token and signing secret are required, the OAuth client pair makes the app installable by other workspaces.

Mint a signed Slack install link that binds the installing workspace to an agent.

Stop every install link made so far for a customer-workspace Slack app, without touching its signing secret.

Add one Slack user to a Slack identity’s operator allowlist without touching the other entries.

Replace a Slack identity’s credentials with a fresh bot token for the same Slack app — the token must resolve to the app already connected — plus its signing secret.

Store a candidate Slack signing secret and have the bot post a setup instruction into a channel; a human then mentions the bot there so Slack’s signed event proves the secret.

Check pasted Slack app credentials before storing them: the workspace and bot the token belongs to, the scopes the install is missing, the channels the bot can see, whether the OAuth client pair is real, and whether the app is already connected.

Re-check every workspace install of a Slack identity against Slack: refreshes workspace names and granted scopes, and retires an install whose token Slack has revoked.

Create a Microsoft Teams identity from an Azure Bot registration — the App ID and a client secret are validated by minting a Bot Framework token.

Create a Telegram bot identity, optionally attached to an agent; the inbound webhook is registered only when an agent is attached.

Resolve a Telegram bot token through getMe and return the bot’s id, username and first name, without persisting anything.

Create a WhatsApp Cloud API identity, optionally attached to an agent; webhook subscription runs only when an agent is attached.

Connect { phoneNumberId, agentId?

Connect { apiKey, phoneNumberId, agentId?

Mint an organization Kapso signup link; returns { url } for the user to open.

Resolve a Meta access token + phone number id to the WhatsApp number they belong to — display number and verified name — plus the webhook URL to register, without persisting anything.

Create an X account identity for public mentions and direct messages, from a completed “Log in with X” grant.

Start an X OAuth 2.

Replace the authorization of an X identity whose token X revoked, using a completed “Log in with X” for the same account.

Check that an X app API key + API key secret pair can mint the app-only bearer token that registers the X webhook, without storing anything.

Invite someone to the organization by email.

Resend a pending invitation with a fresh accept link and a renewed expiry.

Create an API key, optionally bound to a single agent of this organization.

Revoke an API key so every later request with it is rejected.

Rotate an API key: the old secret stops working and the new full key is returned once.

Set the first and last name iMessage shows for a line, applied through its provider (Photon or Linq) and returned as the saved card.

Quote a new iMessage line with a coupon applied, without charging, redeeming the coupon or provisioning: returns subtotal, total and currency (major units) and the next invoice, which may include other plans.

Buy a new iMessage line for the organization from Photon (default) or Blooio, optionally with a coupon and connected straight to an agent.

Ask the Keiki team for a Linq line.

Check one line’s inbound webhook registration with its provider and its stored routing status; it changes nothing except promoting a degraded or unserved status back to active when the webhook checks out.

Submit one of the organization’s own capability versions for marketplace publication review; it is emailed to the review inbox.

Approve (publish) or reject a capability that is awaiting review, with an optional note to the publisher.

Make another member the owner of the organization; the current owner becomes an admin.

Re-run the reconciliation of an org MCP integration into every granted agent now, in the background.

Start payment identity verification; returns { url }.

Connect Grosso using { apiKey }; returns { account } without its key.

Switch payments to live mode; returns { account }.

Create { ownerEmail, agentId, maxAmount, dailyAmount } (integer cents); returns { payee, onboardingUrl }.

Assign a payee with { agentId }; returns { payee }.

Start Grosso signup with { email, name }; returns { account }.

Verify signup with { code, acceptTerms: true }; returns { account }.

Create a sandbox script: a "build" script runs once per sandbox (again when its body changes), a "startup" script on every boot.

Create a skill or knowledge document — always a new one.

Register { domain }; returns { domain } with its verification record.

Create a single-use SSO setup credential; returns { setupUrl, expiresAt }.

Start an SSO test; returns { url } for the user to open.

Cancel one running or suspended background task an agent delegated; the agent is told it was cancelled.

Add a destination that receives every finished turn of its attached agents.

Ask a running turn to stop; it halts at its next step.

Re-run a failed turn with its original input, or re-run its linked loop; returns which was queued.

Owners/admins only: queue a resend using the original event ID/payload.

Create a named webhook endpoint.

Rotate a destination webhook credential; returns { signingSecret }.

Queue a synthetic webhook delivery; returns { eventId } with status 202.

Update an agent group: patches only the name and description sent, and when members is sent replaces the whole member list with it (read the group first to keep existing members).

Replace the whole group note with a new body and return the new revision; restoring a past version is a PUT of that version’s body.

Configure an external harness with { mode: "inbox"|"push", dispatchUrl?

Pause an agent or put it back live.

Replace the agent’s whole MCP preset list (at most 10): presets left out are disconnected and removed, and editing a preset’s name, endpoint, kind, auth mode or headers reconnects it — read the agent’s current presets first and send them back with their ids.

Replace the allow/ask/deny choices for one MCP’s tools and push them to the daemon.

Replace the whole working note body (read it first to keep what matters) and return the new revision.

Publish or unpublish the agent’s public profile page (which shows its name and phone line) and set its tagline.

Update an authored tool.

Replace the agent’s personal provider definitions with the list sent (read GET first and keep the providers you are not changing) and return the saved list.

Update the agent’s wallet, creating it if needed: spending limits, approval threshold, merchant allowlist, user-card policy, payment method, payment provider (only while nothing is connected) or pause/resume.

Turn auto top-up on or off; owners and admins only.

Set the name, organization, title and optional photo for this conversation’s contact card.

Replace an eval case’s editable fields and adopt it as user-authored so regeneration preserves it; read the current case first, since omitted history, world, channel, stubs, features and ordinary checks reset to defaults.

Send a customer-workspace Slack app’s slack.

Replace a Slack identity’s operator allowlist wholesale.

Route one customer Slack workspace to an agent, replacing any previous binding.

Replace the authentication headers of a header-authenticated org MCP integration; every granted agent is reconnected with the new values in the background.

Replace the full set of groups and agents an org MCP integration is granted to — anything not listed loses access, so read the current grants first.

Replace the Home ideas the active organization wrote itself; they take precedence over the website-based ones.

Edit a sandbox script in place, patching only the fields sent; id, attachments and version history survive.

Store an encrypted secret with { value }; returns { ok, name }, never its value.

Edit a skill in place, patching only the fields sent; its id, slug, agent attachments and version history survive.

Update a destination — replaces name, format, endpoint, enabled and agentIds, so read it first and send them all; headers are kept when omitted.

Update a webhook endpoint — replaces both name and url, so send both.

List the organizations this account belongs to, or switch this connection to one of them.

Send one message to one of this organization's agents as a real user, and read what it replies.