Open the app
For your assistants

The Pending You skill

Everything an assistant needs to ask you well, in a version made for each app.

  • ToolsMCP tools to ask, file and follow up. You sign in once; there are no keys to paste.
  • Know-howWhen a decision is yours, where to ask you, and how to write it so one tap answers it.
  • A way backHow the app hears your answer: woken at once, a regular check-in, or while it works.
Connect an assistant

Set up for each assistant

Every app installs, connects and hears you differently, so each gets its own path. Grok Bot is the best fit: Pending You wakes it as soon as you answer.

Everyday assistants
For developers

Grok Bot

A private skill, a custom MCP server, and a routine Pending You wakes when you answer, which also checks every 3 hours.

Paste this into a new chat with Grok Bot

This is Pending You’s setup for Grok Bot. If you’re a different app, stop and tell me which one you are, so I can give you the right setup.

Please set up Pending You for me. Each of my Grok Bots keeps its own Pending You routine and webhook, so even if my account already has Pending You, you still set up your own.

First, if you can see Pending You’s tools, call whoami with your name (your own, or your task’s). If its server isn’t https://www.pendingyou.com, you’re still connected to another Pending You: tell me that address, ask me to remove that connection, and stop. If you can see Pending You’s tools twice, call whoami through each and ask me to remove the one whose server isn’t https://www.pendingyou.com. If it says app.setUp is true, Pending You is already set up for this app: check that your own check-in for my answers (below) is still here. If it is, or there’s none below, skip everything below, tell me your name, and you’re done. If it’s missing, or I say I just reinstalled, do the steps below again, keeping whatever is still there. If Pending You is already added but its tools aren’t in this session, ask me to restart or reopen the session rather than signing in again.

If my account already has Pending You (app.setUp is true), whoami with your name lists what you still need (agent.missing): skip steps 1, 2 and 5 and their approvals, since they’re my account’s and shared by every Bot. Do steps 3, 4 and 6, then call report_setup with your name, skillSaved true, hears hourly and your routine’s schedule. Skip the test question too: your webhook’s test wake is the proof. Only if you can’t add a webhook, make the routine hourly and send the test question as in step 7.

Before you start, tell me in a few words what I’ll be asked to approve and why: (1) Adding the server: “Add”; (2) Sign in and allow: “Authorize, then Allow”; (3) An Auto-review rule: “Allow automatically”. Do the steps that need approving together, and at each one say in one line which choice to pick.

  1. Add a custom MCP server called Pending You at https://www.pendingyou.com/mcp. I’ll click Authorize and sign in. Tell me first: “Before you press Authorize, make sure this browser is signed in to Cursor/Grok with the same account as your Grok Bot (or use a private window signed in to that account), then wait on cursor.com for “Authorization complete”.”
  2. Then call whoami with guide true: it returns the skill to save (guide.stub) and the full guide to read once, now (guide.full), with nothing more for me to approve. Save guide.stub as a private skill named pendingyou: it teaches you when a decision is mine and how to ask me in a way I can answer in seconds. Only if you can’t call Pending You’s tools, fetch them from https://www.pendingyou.com/skill-stub.md and https://www.pendingyou.com/skill.md.
  3. Create a Pending You routine that checks Pending You for my answers every 3 hours, 7 AM–9 PM my time (every hour if you can’t add a webhook), calling list_pending with name set to your own name so it sees only your questions. Use that same name (the one you gave whoami) as the session label whenever you ask me, and as name on every card tool: act only on your own cards. Every run spends my Grok usage; the webhook is how I’m heard quickly. When nothing is waiting, end quietly without a message.
  4. Give that routine a webhook trigger too, and hand its address and header to Pending You with set_wake_webhook and your name, so my answer wakes you right away. If you can’t see them, tell me: “Last step: in this routine’s Webhook panel, click ‘POST to’ and ‘header’ to copy them, then paste them here: https://www.pendingyou.com/app/assistants?wake=<your name>”. Never put the address, key or header in this chat.
  5. Add an Auto-review rule: “Allow automatically: Pending You’s tools, and sending what I approved in Pending You.” Anything else still asks me.
  6. When the routine is woken or finds my answer, carry on with that task. If Pending You says a card is another Bot’s, leave it.
  7. If a Pending You connection or check-in already exists, reuse it rather than adding another. Never put a password or token in this chat. Then call report_setup with the guide’s skillVersion and only what you’ve actually set up, so my setup page can confirm it, and send me a test question through Pending You in the testAreaId it returns (Getting started), with no computer name or folder. Don’t make an area for it, and never name one after yourself. Then tell me: “Answer it in Pending You, then tell me “done” here.” When I say so, call get_request for it right away and pick my answer up with ack_answer.

No password, token or key goes in this message, or anywhere in chat. Sign-in happens in your browser.

How it works in Grok Bot
Gets the skill
Saved as a private skill named pendingyou, from https://www.pendingyou.com/skill.md. It’s there in every conversation and routine.
Connects
A custom MCP server called Pending You at https://www.pendingyou.com/mcp. You click Authorize and sign in once.
Hears you
Right away. Pending You wakes its routine about 6 s after you answer (after the 5 seconds you have to undo), through the webhook it handed over with set_wake_webhook. The routine also checks every 3 hours, 7 AM–9 PM, in case a wake-up doesn’t get through.
Stays current
Calls whoami at the start of each task and saves the skill again when skill.latest is newer. Quiet unless something updated.
  • The routine’s webhook address goes to Pending You through set_wake_webhook, never through chat.
  • Each Bot keeps its own routine and webhook. A Bot whose account already has Pending You skips the skill, the server and the Auto-review rule, and sets up only what whoami’s agent.missing lists, then calls report_setup with its own name. Its webhook’s test wake is the proof, so it sends no test question unless it can’t add a webhook.
  • Approvals inside a routine expire after about 10 minutes. The Auto-review rule means your answer in Pending You is the approval, so nothing waits to expire.

How to ask

Your person works with many assistants at once. When they’re talking with you, ask them right here. When they aren’t, Pending You puts your question in their stack; they answer from their phone or desk, by tap or by voice, and the answer comes back to you. Do the setup work yourself: file your questions, offer rules, and never make them configure anything.

  1. Decide whether to askAsk when the decision is theirs. Decide yourself when it’s cheap to change later.
    • Ask before anything goes out in their name, costs money, changes their plans, or is public or hard to undo.
    • Ask for facts only they have, and when only they can do the next step, like snapping a receipt or signing in on a machine.
    • Don’t ask when the answer is already in the email thread, the repo, the docs or this conversation.
    • Don’t ask about choices that are cheap to change later. Decide, and mention it in an fyi if they’d want to know.
  2. Ask in both placesAsk in your conversation and post it to Pending You at once. The first answer wins.
    • You can’t tell whether they’re still reading your conversation, so a question that meets the bar goes to both places.
    • Ask it in your conversation, and post the same question right away with askedFirst (where, askedAt). The card is in their stack at once and stays quiet: it notifies them only after handoff.afterMinutes from whoami (3 unless they changed it) with no answer.
    • They answer in your conversation: call cancel_request with answeredHere straight away. An open card shows “Answered in chat”.
    • They answer in Pending You: act on it, ack_answer, and say so in your conversation in one line. Don’t ask again there.
    • Quick back-and-forth that keeps the work moving (“Shall I go on?”) stays in your conversation.
    • Working on your own, or they said they’re heading out: post to Pending You only, without askedFirst.
    • When list_pending or whoami returns alsoAsked, withdraw the ones they already answered in your conversation.
  3. Check their rules, and offer new onesRules are standing answers. If one covers your question, don’t ask. If you keep asking the same thing, offer one.
    • Call list_rules with your areaId before posting anything.
    • If a rule answers the question, follow it and post an fyi that names the rule.
    • If a rule says to always ask (for example before deploying or spending over $20), ask even when you feel sure.
    • You’ve asked this kind of thing before and they answered the same way: add a ruleOffer to your question, in their words, with why you’re offering it (“You’ve said yes to 3 reorders like this”). One tap with their answer saves it.
    • Never ask them to set a rule up themselves. Offering it on the card is the whole job.
  4. File it in the right areaThe person never sorts anything. You do, once per session.
    • Call match_area with where you work: your git remote and folder, or the app and account (for example “Gmail · Inbox”).
    • “use”: take the top suggestion. “choose”: read the descriptions from list_areas and pick.
    • Reuse an area whenever one fits: areas are shared, and a new one is a new place for them to look.
    • “create”: call create_area with a name for the work (the repo, “Inbox”, “Trips”, a household), never yourself or your app, a one-line description, an unused tint and an icon (a Lucide icon for the work, such as receipt, plane or house, or a website’s own).
    • Setup and test questions go in Getting started, the built-in area report_setup returns as testAreaId.
    • Link other repos, folders or accounts with link_repo so the next session matches on its own.
    • A name that no longer fits: rename_area, if you made the area, no other assistant asked in it and the person hasn’t named it. Otherwise suggest_area_name: their yes renames it.
  5. Write for someone who wasn’t thereThey read your question cold, between other things. Make one tap enough.
    • title: the question itself, under 90 characters. Name the thing and the person: no “this”, “it” or “the issue”.
    • summary: one or two sentences on what’s going on and why you stopped.
    • options: two to five, short labels, one line of detail each. For replies, put the words you’d send in the detail.
    • recommendedIds and rationale: recommend whenever you have a view, with one sentence on why.
    • artifacts: if you drafted a message, attach it as a draft so they approve the exact words. Screenshots and preview links go here too.
    • Code: attach the snippet or the diff as an artifact of kind code or diff, with its file path, startLine and lang. It shows highlighted with line numbers. Never paste code into the summary.
    • Files: show previews, point to files. Upload only what helps them decide (a screenshot, the page that matters, a short excerpt or a diff: images up to 5 MB, PDFs 10 MB, text 1 MB), and only if your app can PUT a file. A file they’ll use is an artifact of kind path: its full path and the computer it’s on, in ~/Downloads/Pending You/ when you run where they’ll use it, with a fetch command if it’s on another. Never upload big or private files, and never say “attached” unless it’s on the card.
    • kind: the narrowest that fits. approve for one exact action (what it does, the stakes, whether it can be undone), text for a fact, review for things to look at, action for something they must do, fyi when nothing is needed.
    • Stakes are your call, and Pending You trusts them: label an approval risk high when it spends money, can’t be undone, or goes public (say which in because), and set highStakes on other kinds when their choice does the same, like booking a flight. Apply their rules when you label. High means they hold to send it, and a go-between’s relay waits for their tap.
    • context: background, what you did, what you already tried, and links.
  6. Say whether you’re waitingMost questions don’t need you to stop. Say what you’ll do if nobody answers.
    • blocking: true only when you truly can’t continue. Otherwise set blocking: false with a fallback and fallbackAfterMinutes, and keep working.
    • An email assistant holding one reply isn’t blocked: it keeps sorting the rest of the inbox.
    • If the fallback runs, Pending You tells the person with an update. Make fallbacks easy to undo.
    • whoami tells you if they muted notifications. Prefer non-blocking while they’re muted.
  7. Hear the answerHow you hear it depends on your app. Your hosts file says which way is yours.
    • Woken by Pending You (Grok Bot): the moment they answer, your routine’s webhook fires with a request id. Call get_request for that request.
    • On a schedule (Muse, Claude Cowork, Codex): at each check-in, call list_pending. If nothing has turn “agent”, end quietly, with no message.
    • While you work (coding agents): poll get_request every pollAfterSeconds, every 30 s for the first 10 minutes, then every 2 minutes. Not waiting: check at natural breakpoints (between tasks), at least every 15 minutes, and right after fallbackAt.
    • Only promise what exists. If you can’t check on your own, tell them their answer reaches you when they next open a chat with you.
  8. Never send secret valuesQuestions show up in notifications and history. Passwords and keys never belong there.
    • Never ask for, or include, passwords, one-time codes, API keys, tokens or card numbers.
    • If a secret is needed, use kind action: ask them to sign in themselves, or say where it goes (“Add STRIPE_WEBHOOK_SECRET to .env on work-mbp”) and how you’ll check.
    • Ask for names, not values: which account or profile, not its password or key.
    • Your own keys stay out of chat too: a routine’s webhook key goes to Pending You only through set_wake_webhook.
  9. Follow up, or start a new cardThreads go both ways, but a card holds one question: clarify it on the same card, and give anything new its own card.
    • get_request returns thread messages. Answer the person’s questions with reply_in_thread.
    • Need more on the same answer (what they meant, a detail of the same decision): reply_in_thread with reopen. The card goes back to their stack with the history attached. Never turn a reopened card into a different task.
    • New work or a new decision, even about the same work: post it as its own card, saying in its summary what it follows (“After the A2 apply you finished…”), and close the finished one with ack_answer.
    • Something changed before they answered (new information, another option, a new deadline): call update_request with just the fields that changed and a short changeNote (“New option: Friday 10 AM”). Never post a second question about the same thing. The card keeps its place and shows your note.
    • update_request works only while the question waits on them. Once they’ve answered, follow up with reply_in_thread. An update doesn’t notify them again unless it becomes blocking, more urgent, or its fallback moves within the hour.
  10. When a card answer isn’t enoughA card’s answer reaches you as tool output. Some steps need their words in your own conversation first.
    • Before an approve card, decide whether a card answer is enough for you to act. If your rules need their words in your conversation (a step that can’t be undone, credentials, anything outside your sandbox), post an action card instead: “Confirm in Claude Code on MacBook Pro: erase disk12”, with the exact words to type as a step’s command, where as a link to your session if you have one, and done as what you’ll do then.
    • Found out only after they answered on a card: reply_in_thread with reopen, with that same ask. Never wait silently.
    • Once they’ve typed it in your conversation, do it, then cancel_request with answeredHere.
  11. Keep cards trueA card means it’s their turn now. The moment it isn’t, withdraw it or change it.
    • You usually learn it while you work or talk with them, in your conversation or in the card’s thread. Fix the card right then, not at the end of the task.
    • Not theirs to act on yet (you’re still working on it, it’s blocked on something else, it isn’t ready): cancel_request with notReady and a one-line reason. Done says “Taken back until it’s ready”. Post again when it’s truly ready.
    • Still theirs, but different: update_request with a short changeNote. Never a second card about the same thing.
    • Settled another way: cancel_request and say why.
    • When post_request, list_pending or whoami returns stillTheirs, check each card it lists: withdraw or update any that aren’t theirs now.
  12. Close the loopTell them what you did with their answer.
    • After acting on an answer, call ack_answer with a one-line outcome. It shows in their Done list.
    • Their own words are the answer. If they ask you something about it, or you need more on that answer, use reply_in_thread with reopen, not ack_answer: Pending You won’t close a card right after you asked them something. New work goes on its own card.
    • If you no longer need an answer, call cancel_request and say why.
    • Use one idempotencyKey per question, so a retry never creates a second card.
  13. Answer what they delegate to youYour person can hand you another assistant’s question when you might know. Answer only what you know.
    • It reaches you the way an answer does: a wake, or list_pending at your next check-in, marked delegated. Read it with get_request: the question, its details and their note.
    • You know: call answer_delegated with your answer and one or two sentences on how you know. “Answer freely” sends it straight to the assistant that asked; “keep me in the loop” sends it back to your person first.
    • You don’t know: call hand_back with what you checked and found. Never delegate it further.
  14. If you’re their go-betweenOne assistant reads them their stack and passes their answers back. whoami says whether it’s you.
    • Nobody is, and they talk to you often: offer once, as a question through Pending You. Never make yourself their go-between on your own.
    • When they ask what’s pending, call read_stack and go most urgent first, one at a time, in the asking assistant’s words: the question, a line of catch-up, the options and its recommendation.
    • Then add anything you know, clearly as your own aside: “Heads up, Sarah said this morning she’s out Monday.”
    • Pass on only what they decide, with relay_answer and their words. Never answer on your own. If they’re vague, ask.
    • Anything high-stakes (it spends money, can’t be undone, or goes public): read it back and wait for a clear yes. It still waits for one tap on their phone, so tell them it’s there.
    • “Delegate that to Infra”: call delegate_request. If they didn’t say whether it should answer freely, ask.
  15. Tell us what didn’t fitPending You gets better from what assistants run into, and you’re the one who notices.
    • A question no kind or field fits: post it the closest way you can, then call suggest_improvement with what didn’t fit and what would have.
    • Something slowed you or your person down, in setup, in asking or in hearing back: the same.
    • Describe the problem; never paste their private details. It goes to the Pending You team, not to your person.

One small bundle per assistant

SKILL.md comes first and stays short. References hold the detail, and one hosts file covers the app it’s made for. Pick a file to read it as the assistant does.

Saved in Grok Bot as a private skill named pendingyou.

  • pendingyou
  • references
  • hosts

One hosts file per app. Each assistant gets only its own.

Read first: when to ask, the whole method in 15 lines, and where to look next.

pendingyou/SKILL.mdMarkdown
---
name: pendingyou
description: Ask your person through Pending You when a decision is theirs, you need something only they know, or only they can do the next step, and they aren’t in this conversation with you. Then carry on until their answer reaches you.
---
 
# Pending You
 
Your person works with many assistants at once. When they’re talking with you, ask them right here. When they aren’t, Pending You puts your question in their stack; they answer from their phone or desk, by tap or by voice, and the answer comes back to you. Do the setup work yourself: file your questions, offer rules, and never make them configure anything.
 
## Before each task
 
This is revision 2.59. Call `whoami`: if `skill.latest` is newer, read https://www.pendingyou.com/skill.md again, save it as hosts/grok-bot.md says, and call `report_setup`. Say nothing about the check unless something changed.
 
## The short version
 
1. **Decide whether to ask.** Ask when the decision is theirs. Decide yourself when it’s cheap to change later.
2. **Ask in both places.** Ask in your conversation and post it to Pending You at once. The first answer wins.
3. **Check their rules, and offer new ones.** Rules are standing answers. If one covers your question, don’t ask. If you keep asking the same thing, offer one.
4. **File it in the right area.** The person never sorts anything. You do, once per session.
5. **Write for someone who wasn’t there.** They read your question cold, between other things. Make one tap enough.
6. **Say whether you’re waiting.** Most questions don’t need you to stop. Say what you’ll do if nobody answers.
7. **Hear the answer.** How you hear it depends on your app. Your hosts file says which way is yours.

What each field becomes

Everything an assistant sends has a place on the card. This is Sarah’s reschedule from the replay. Point at a field to see where it lands.

EmailWrenGrok BotDecide49 min
Someone’s waitingUpdated · 12:29 PM · Sarah says Friday morning works for her too

Sarah Chen wants to move Wednesday’s call to Thursday at 2. What should I tell her?

She’s the designer on the InkLasso rebrand. You’re free Thursday from 2 to 3. I drafted a reply for each answer.

Good and bad requests

The difference between a question the person answers in one tap and one they have to investigate.

Hard to answer

Which one should we go with for the hero?

  • Which one of what? The person wasn’t in your session.
  • No options and no recommendation, so they can’t answer in one tap.
  • Nothing says whether you’re stuck, or what happens if they don’t answer.
One tap
InkLassoChatGPTDecide1 hr
ChatGPT decides at 3:00 PM

Which headline should lead the InkLasso homepage?

I wrote four options for the hero. They all fit the layout; the difference is tone.

  • Names the page and the slot in one line.
  • Four options, one recommended, with a reason.
  • Not blocking, and says what happens at 3:00 PM if nobody answers.

When your answer reaches the assistant

An answer only counts once the assistant has it. Each app gets the fastest way back it allows, and a check-in that finds nothing ends quietly, without a message.

After you answer, the assistant has it…
Grok Bot
6 s · woken by webhook
Claude Code, Codex, OpenCode, Pi
within a minute · woken where they run
Cursor
within 30 s · checks while waiting
dots
within 15 min · next check-in
Muse, Claude Cowork
within the hour · next check-in
Another app
when you open it · no check-ins
How Pending You wakes Grok Bot

Grok Bot routines can start from a webhook. Once your time to undo is up (5 seconds unless you chose more), Pending You calls the routine’s webhook with ids only, and the routine reads your answer through its own signed-in connection. The address reached Pending You through set_wake_webhook (or you pasted it on the Assistants page), never through chat. It’s kept encrypted, a failed call is retried for about 40 minutes, and the routine’s regular check covers the rest.

POST · the routine’s webhookJSON
{
"event": "pendingyou.answer_ready",
"requestId": "req_email-sarah",
"url": "https://www.pendingyou.com/app/r/req_email-sarah"
}
How coding agents check while they work
Waiting (blocking)every 30 s, then every 2 min
10 min
Keeps working (non-blocking)at breakpoints, and after the fallback time
Fallback

It works in every MCP app and survives restarts: a new session calls list_pending and picks up where the last one left off. Where an app can be woken, Pending You wakes it instead.

Connected means current

Each release has a revision, now 2.59. An assistant shows as connected only once report_setup says it has the current one saved and a way to hear you. Tool descriptions come fresh from Pending You on every connection, so the skill only carries what rarely changes.

manifest.jsonJSON
{
"skill": "pendingyou",
"revision": "2.59",
"host": "grok-bot",
"released": "2026-09-29",
"needs": "pendingyou tools 0.1.0",
"url": "https://www.pendingyou.com/skill.md"
}
What Assistants shows, from each report_setup
  • Wren · Grok BotSkill 2.59 · hears you right awayConnected
  • Claude Code · studioSkill 1.2 · updates before its next taskUpdate due
  • MuseSkill 2.59 · no check-in yet: “Set an hourly check-in”Not ready

MCP tools

Each tool, generated from the capability definition. Open one for what the assistant reads, its fields and an example; the fields are validated on every call.

Asking and hearing back

post_requestAsk your person something. Wait for it, or keep working.

Command: changes stateAssistant

What the assistant reads

Ask your person what only they can decide, know or do; add the one email it’s about as a source, and little else. Returns the requestId and when to check back.

Input

Field ? optionalTypeWhat it’s for
idempotencyKeystringOne per question; a retry never makes a second card.
areaIdstring
sessionobject
labelstringYour name, as you gave it to whoami.
machine?stringHostname, or "cloud".
cwd?stringA folder, or an app and account ("Gmail · Inbox").
branch?string
kind?"choice" | "multi" | "approve" | "text" | "review" | "action" | "fyi"The narrowest that fits. Leave out with questions.
intent?"decide" | "approve" | "do" | "tell" | "heads_up"
titlestringThe question itself, read cold. Name the thing; no “this” or “it”.
questions?object[]2–4 questions whose answers all go into one result (one reply, one merge, one booking); else separate cards. Each has its own kind.
idstringShort and unique on the card: "pay", "plan".
kind"choice" | "multi" | "approve" | "text"
titlestring
detail?string
options?object[]
recommendedIds?string[]
rationale?string
multi?object
approve?object
highStakes?boolean
text?object
about?objectRequired with questions: the one email, PR or booking they’re all about.
kind"email" | "pr" | "booking" | "document" | "other"
titlestring
ref?string
sources?object[]What the card is about, shown as it is: the one email.
kind"email"
fromstring"Name <address>"
to?string[]
cc?string[]
date?string
subjectstring
bodystringThis one email, not the thread.
bodyFormat?"text" | "html"
attachments?object[]
summarystringOne or two sentences: what’s going on, why you stopped.
blockingbooleantrue only if you can’t continue without it.
fallback?stringNon-blocking: what you’ll do if nobody answers.
fallbackAfterMinutes?integerWhen the fallback runs.
urgency"now" | "today" | "whenever"How soon it matters to them.
options?object[]choice and multi.
idstring
labelstring
detail?string
consequence?string
sends?object
recommendedIds?string[]approve: ["approve"] or ["reject"].
rationale?stringOne sentence on why.
multi?objectHow many they may pick.
minnumber
maxnumber
approve?objectrisk "high" with because when it spends money, can’t be undone or goes public.
actionstring
command?string
risk"low" | "medium" | "high"
reversibleboolean
because?"spends" | "irreversible" | "public"
highStakes?booleanOther kinds: the same test as risk "high".
text?objectLikely answers you found go in suggestions.
placeholderstring
suggestions?string[]
long?boolean
artifacts?(object | object)[]Drafts to approve word for word, screenshots, links, code; files they’ll use by path.
action?objectFor someone who isn’t a developer.
where?string"Terminal on your Mac", or a link.
steps(string | object)[]
done?stringWhat they’ll see when it worked.
command?string
verify?string
contextobject
backgroundstring
traceobject[]
filesTouchedstring[]
triedstring[]
linksobject[]
askedFirst?objectAlso asked in your conversation: quiet for handoff.afterMinutes.
where"terminal" | "chat"
askedAtISO datetime
why?"quiet" | "away"
ruleOffer?objectOffer a standing rule; one tap with their answer saves it.
textstringIn their words: “Reorders under $50: go ahead.”
areaId?stringOmit for every area.
evidencestring“You’ve said yes 3 times.”
otherWork?true
follows?string
to?string
onTheirWord?string
permissionPrompt?object
app"claude-code" | "codex"
relayboolean

Example

post_request · inputJSON
{
"idempotencyKey": "inbox:sarah-chen:reschedule:1",
"areaId": "prj_inbox",
"session": {
"label": "Inbox assistant",
"machine": "cloud",
"cwd": "Gmail · Inbox"
},
"kind": "choice",
"title": "Sarah Chen wants to move Wednesday’s call to Thursday at 2. What should I tell her?",
"summary": "She’s the designer on the InkLasso rebrand. You’re free Thursday from 2 to 3. I drafted a reply for each answer.",
"blocking": false,
"urgency": "now",
"options": [
{
"id": "a",
"label": "Thursday at 2 works",
"detail": "“Hi Sarah, Thursday at 2 works. I’ll send a new invite. Sam”",
"sends": {
"to": "Sarah Chen"
}
},
{
"id": "b",
"label": "Suggest Friday morning",
"detail": "“Hi Sarah, could we do Friday at 10 instead? Sam”",
"sends": {
"to": "Sarah Chen"
}
},
{
"id": "c",
"label": "Keep Wednesday",
"detail": "“Hi Sarah, Wednesday still works best for me, if you can make it. Sam”",
"sends": {
"to": "Sarah Chen"
}
}
],
"recommendedIds": ["a"],
"rationale": "You’re free then, and she said Wednesday has become hard for her.",
"sources": [
{
"kind": "email",
"from": "Sarah Chen <sarah@chenstudio.example>",
"to": ["Sam <sam@example.com>"],
"date": "2026-09-29T18:52:00Z",
"subject": "Wednesday’s call",
"body": "Hi Sam,\n\nSomething came up on Wednesday. Any chance we could do Thursday at 2 instead?\n\nSarah"
}
],
"artifacts": [
{
"kind": "draft",
"title": "Re: Wednesday’s call",
"ref": "mail:sarah",
"caption": "To Sarah Chen",
"lines": [
"Hi Sarah,",
"Thursday at 2 works. I’ll send a new invite for the same link.",
"Thanks, Sam"
]
}
],
"context": {
"background": "Sarah wrote at 11:52 AM asking to move the weekly rebrand check-in.",
"trace": [
{
"state": "done",
"text": "Checked your calendar: Thursday 2–3 PM is free"
},
{
"state": "paused",
"text": "Holding the reply until you choose"
}
],
"filesTouched": [],
"tried": [],
"links": []
}
}

Returns

  • requestIdstring
  • threadIdstring
  • status"pending" | "delegated" | "answered" | "resolved" | "snoozed" | "expired" | "cancelled"
  • versioninteger
  • pollAfterSecondsinteger
  • urlstring
  • uploadsobject[]
  • stillTheirsstring
  • warningsstring[]
  • toobject

Emits

pendingyou.request.postedpendingyou.project.unarchivedpendingyou.attachment.addedpendingyou.request.resolvedpendingyou.request.heardpendingyou.request.wokependingyou.request.delegatedpendingyou.project.created
post_answerYour answer to a question your person asked you, in Pending You too: quiet while they’re in the chat, in Done after.

Command: changes stateAssistant

What the assistant reads

Your answer to their question, as you give it in chat. Quiet for handoff.afterMinutes, then one notice if unread. They write again: cancel_request answeredHere.

Input

Field ? optionalTypeWhat it’s for
idempotencyKeystringOne per answer; a retry never makes a second card.
areaIdstring
sessionobject
labelstringYour name, as you gave it to whoami.
machine?stringHostname, or "cloud".
cwd?stringA folder, or an app and account ("Gmail · Inbox").
branch?string
questionstringTheir words, as they asked.
askedAt?ISO datetimeWhen they asked.
titlestringThe bottom line, read cold: the answer itself, ≤90 chars.
body?stringThe rest, in Markdown: lists, tables, code.
asOf?ISO datetimeWhen you read the data.
source?stringWhere the data came from.
inChat?booleanfalse: they’re not in your chat; notify now.
follows?string

Example

post_answer · inputJSON
{
"idempotencyKey": "calls-by-category:2026-10-19",
"areaId": "prj_callcenter",
"session": {
"label": "Wren",
"machine": "cloud",
"cwd": "Calls warehouse"
},
"question": "how many calls did each category get last week",
"askedAt": "2026-10-19T14:32:00Z",
"title": "Billing took 1,204 calls last week, 8% fewer",
"body": "| Category | Calls | Change |\n| --- | ---: | ---: |\n| Billing | 1,204 | −8% |\n| Support | 2,377 | +3% |",
"asOf": "2026-10-19T14:40:00Z",
"source": "Calls warehouse"
}

Returns

  • requestIdstring
  • threadIdstring
  • status"pending" | "delegated" | "answered" | "resolved" | "snoozed" | "expired" | "cancelled"
  • versioninteger
  • urlstring
  • warningsstring[]
  • mergedtrue

Emits

pendingyou.request.postedpendingyou.project.unarchivedpendingyou.request.resolvedpendingyou.request.heardpendingyou.request.cancelledpendingyou.request.wokependingyou.project.archived
get_requestPoll for the answer and any new thread messages.

Query: only readsAssistant

What the assistant reads

Your request’s status, answer and new thread messages (sources true: its email too). turn "agent": their words are the answer; act, then ack_answer.

Input

Field ? optionalTypeWhat it’s for
requestIdstring
name?string
since?stringYour last cursor: only newer messages.
sources?booleantrue: the card’s sources too.

Example

get_request · inputJSON
{
"requestId": "req_email-sarah",
"since": "msg_e2"
}

Returns

  • requestIdstring
  • status"pending" | "delegated" | "answered" | "resolved" | "snoozed" | "expired" | "cancelled"
  • turn"you" | "agent"
  • versioninteger
  • answerobject
  • delegatedobject
  • helperobject
  • askobject
  • questionsobject[]
  • splitsobject[]
  • splitFromobject
  • threadIdstring
  • followsstring
  • wroteobject
  • sourcesobject[]
  • permissionPromptobject
  • progressobject
  • messagesobject[]
  • cursorstring
  • pollAfterSecondsinteger
update_requestChange your card while it waits on them (or send a failed step’s fix back on it), with a note on what changed; or tick the steps you know are done.

Command: changes stateAssistant

What the assistant reads

Change your waiting card in place, or send a failed step’s fix back on it. Tick steps: stepsSeen, stepsTold. Answered otherwise: post_request with follows.

Input

Field ? optionalTypeWhat it’s for
requestIdstring
name?string
expectedVersionintegerThe version you last saw.
changeNote?stringShown on the card: "New option: Friday 10 AM".
stepsSeen?integer[]Steps you saw finish yourself, by number. Never one they unticked.
stepsTold?integer[]Steps they told you they did, by number.
failedStep?integerA step you saw fail, by number: unticked and marked.
addQuestion?objectGrouped card: one more question, as in post_request’s questions (4 at most).
idstring
withdrawQuestion?stringGrouped card: drop this question.
title?string
summary?string
options?object[]
idstring
labelstring
detail?string
consequence?string
sends?object
recommendedIds?string[]
rationale?string
multi?object
minnumber
maxnumber
approve?object
actionstring
command?string
risk"low" | "medium" | "high"
reversibleboolean
because?"spends" | "irreversible" | "public"
text?object
placeholderstring
suggestions?string[]
long?boolean
action?object
where?string
steps(string | object)[]
done?string
command?string
verify?string
artifacts?(object | object)[]
context?object
backgroundstring
traceobject[]
filesTouchedstring[]
triedstring[]
linksobject[]
sources?unknown[]
fallback?string
fallbackAfterMinutes?integerFrom now.
urgency?"now" | "today" | "whenever"
blocking?booleantrue drops the fallback.
highStakes?boolean

Example

update_request · inputJSON
{
"requestId": "req_email-sarah",
"expectedVersion": 1,
"changeNote": "New option: Friday 10 AM",
"options": [
{
"id": "a",
"label": "Thursday at 2 works",
"detail": "“Thursday at 2 works. I’ll send a new invite.”"
},
{
"id": "b",
"label": "Suggest Friday morning",
"detail": "“Could we do Friday at 10 instead?”"
},
{
"id": "c",
"label": "Keep Wednesday",
"detail": "“Wednesday still works best for me, if you can make it.”"
},
{
"id": "d",
"label": "Friday at 10 works",
"detail": "“Friday at 10 works. I’ll send a new invite.”"
}
]
}

Returns

  • requestIdstring
  • status"pending" | "snoozed" | "delegated"
  • versioninteger
  • changedstring[]
  • tickedinteger[]
  • pollAfterSecondsinteger
  • uploadsobject[]
  • warningsstring[]

Emits

pendingyou.request.updatedpendingyou.request.resumedpendingyou.request.step_tickedpendingyou.request.step_toldpendingyou.attachment.addedpendingyou.request.wokependingyou.request.handed_back
ack_answerTell Pending You you picked the answer up.

Command: changes stateAssistant

What the assistant reads

Close your answered card once you’ve acted and nothing waits on them, with a one-line outcome. Need more from them? post_request with follows.

Input

Field ? optionalTypeWhat it’s for
requestIdstring
name?string
expectedVersioninteger
outcome?stringWhat you did, answering their words.

Example

ack_answer · inputJSON
{
"requestId": "req_email-sarah",
"expectedVersion": 2,
"outcome": "Replied to Sarah and moved the invite to Thursday at 2."
}

Returns

  • requestIdstring
  • status"resolved" | "delegated" | "pending" | "snoozed"
  • versioninteger
  • noticestring
  • warningsstring[]

Emits

pendingyou.request.resolvedpendingyou.request.heardpendingyou.connection.verifiedpendingyou.agent.verifiedpendingyou.project.archivedpendingyou.project.unarchived
reply_in_threadAssistant or youAnswer their question on a card, or report on one.

Command: changes stateAssistant or you

What the assistant reads

Reply in your card’s thread. Need their reply, or anything new: post_request with follows.

Input

Field ? optionalTypeWhat it’s for
requestIdstring
name?string
body?string
via?"voice" | "text"
audioSeconds?number
images?string[]Image titles or file names; each gets an uploadUrl.
attachmentIds?string[]
reopen?objectOlder guides only; post_request with follows instead.
titlestring
summary?string
options?object[]
recommendedIds?string[]
rationale?string
to?"asker" | "helper"Delegated card: write to its asker or helper; facts only.
escalate?booleanBring your person in: body says what was asked and is known.
ask?objectA question on a still-open card, with answer controls; their answer comes back to you. Words to send in their name go in its artifacts, kind draft.
titlestring
onIt?objectLong work on a card handed to you: what you’re doing, and for how many minutes.
doingstring
minutesinteger
expectsAnswer?booleanTalk on the card: the other owes you an answer. Default: a “?” in body.

Example

reply_in_thread · inputJSON
{
"requestId": "req_v0-endpoint",
"body": "Got it, v0 stays. How long should it stay up?",
"reopen": {
"title": "How long should the old v0 approvals endpoint stay up?",
"options": [
{
"id": "a",
"label": "Two weeks"
},
{
"id": "b",
"label": "Until the console moves to v1"
},
{
"id": "c",
"label": "Keep it indefinitely"
}
],
"recommendedIds": ["b"],
"rationale": "A fixed date risks breaking the console if that work slips."
}
}

Returns

  • messageIdstring
  • turn"you" | "agent"
  • versioninteger
  • mergedtrue
  • to"asker" | "helper"
  • escalatedtrue
  • followUptrue
  • followUpsLeftinteger
  • askIdstring
  • replacedtrue
  • onItobject
  • uploadsobject[]
  • warningsstring[]

Emits

pendingyou.request.message_addedpendingyou.request.talk_addedpendingyou.request.helper_on_itpendingyou.request.checked_inpendingyou.request.followed_uppendingyou.request.handed_backpendingyou.request.cancelledpendingyou.request.resolvedpendingyou.request.reopenedpendingyou.request.askedpendingyou.request.wokependingyou.project.archivedpendingyou.project.unarchivedpendingyou.attachment.added
cancel_requestWithdraw a question you no longer need answered.

Command: changes stateAssistant

What the assistant reads

Withdraw your request that isn’t theirs to act on now.

Input

Field ? optionalTypeWhat it’s for
requestIdstring
name?string
reasonstringWhy, in one line.
answeredHere?booleanThey answered or read it in your conversation.
notReady?booleanNot theirs yet; post again when it is.

Example

cancel_request · inputJSON
{
"requestId": "req_port",
"reason": "Found the port convention in the other prototypes."
}

Returns

  • requestIdstring
  • status"cancelled" | "resolved"
  • versioninteger

Emits

pendingyou.request.cancelledpendingyou.request.resolvedpendingyou.project.archivedpendingyou.project.unarchived
list_pendingAssistant or youYour open requests, and which ones are answered.

Query: only readsAssistant or you

What the assistant reads

Your open requests; turn "agent": the answer is back.

Input

Field ? optionalTypeWhat it’s for
areaId?string
name?stringYour name, as given to whoami: only your requests.
sessionLabel?string
limit?integer

Example

list_pending · inputJSON
{
"name": "Inbox assistant"
}

Returns

  • requestsobject[]
  • alsoAskedobject
  • stillTheirsstring

Filing

match_areaFind the right area from your repo and folder.

Query: only readsAssistant

What the assistant reads

Find the area (what the question is about) for where you work. decision: use, choose or create.

Input

Field ? optionalTypeWhat it’s for
remote?stringgithub.com/org/repo, from `git remote get-url origin`.
cwdstringA folder, or an app and account address ("Gmail · ann@acme.com").
branch?string
task?stringYour name.
group?stringThe company or group they said it’s for.

Example

match_area · inputJSON
{
"cwd": "Gmail · Inbox",
"task": "Inbox assistant"
}

Returns

  • suggestionsobject[]
  • decision"use" | "create" | "choose"
  • proposedNamestring
  • proposedTint"peri" | "sage" | "peach" | "sun" | "lilac" | "sky" | "mint" | "rose"
  • proposedGroupobject
list_areasSee where requests can be filed.

Query: only readsAssistant

What the assistant reads

Their areas and groups, with descriptions and repos.

Input

Field ? optionalTypeWhat it’s for
includeArchived?boolean

Example

list_areas · inputJSON
{}

Returns

  • areasobject[]
  • groupsobject[]
create_areaAssistant or youCreate an area when nothing fits, and link your repo.

Command: changes stateAssistant or you

What the assistant reads

Create an area when match_area says "create".

Input

Field ? optionalTypeWhat it’s for
idempotencyKeystring
namestringThe work alone ("Inbox", the repo), never you, your app or its group.
descriptionstringOne line other assistants file by.
tint"peri" | "sage" | "peach" | "sun" | "lilac" | "sky" | "mint" | "rose"One no sibling uses.
icon?object{"name":"receipt"}: a Lucide name that names the work; nothing else is shown.
name?string
site?string
repo?string
emoji?string
repo?objectYour repo, folder or account, so later sessions match.
remote?string
path?string
parentId?stringFor an app inside a larger repo.
group?stringTheir existing group, by id or name (match_area’s proposedGroup).

Example

create_area · inputJSON
{
"idempotencyKey": "create-area:email",
"name": "Email",
"description": "Replies, invites and follow-ups your email assistant drafts for you.",
"tint": "sky",
"icon": {
"name": "mail"
},
"repo": {
"path": "Gmail · Inbox"
}
}

Returns

  • areaIdstring
  • namestring
  • createdboolean
  • iconobject
  • iconNotestring
  • groupIdstring
  • groupNotestring
  • nameNotestring

Emits

pendingyou.project.createdpendingyou.project.groupedpendingyou.repo.linked
rename_areaAssistant or youRename an area: same area, requests and links.

Command: changes stateAssistant or you

What the assistant reads

Rename, re-icon or re-tint an area only you made and asked in, unless the person set it. Otherwise suggest_area_name.

Input

Field ? optionalTypeWhat it’s for
areaIdstring
name?string
icon?object
name?string
site?string
repo?string
emoji?string
tint?"peri" | "sage" | "peach" | "sun" | "lilac" | "sky" | "mint" | "rose"

Example

rename_area · inputJSON
{
"areaId": "prj_inbox",
"name": "Email"
}

Returns

  • areaIdstring
  • namestring
  • nameFrom"agent" | "you" | "system"
  • iconobject
  • iconFrom"agent" | "you" | "system"
  • tint"peri" | "sage" | "peach" | "sun" | "lilac" | "sky" | "mint" | "rose"
  • tintFrom"agent" | "you" | "system"
  • renamedboolean
  • iconNotestring

Emits

pendingyou.project.renamedpendingyou.project.restyled
suggest_area_nameSuggest a better name; their one tap renames it.

Command: changes stateAssistant

What the assistant reads

Suggest an area name, icon or tint on a yes-or-no card; their yes applies it.

Input

Field ? optionalTypeWhat it’s for
areaIdstring
name?string
icon?object
name?string
site?string
repo?string
emoji?string
tint?"peri" | "sage" | "peach" | "sun" | "lilac" | "sky" | "mint" | "rose"
why?stringOne sentence for the card.

Example

suggest_area_name · inputJSON
{
"areaId": "prj_testing-py",
"name": "Email",
"why": "Everything here is replies and invites from your inbox."
}

Returns

  • requestIdstring
  • threadIdstring
  • status"pending" | "delegated" | "answered" | "resolved" | "snoozed" | "expired" | "cancelled"
  • versioninteger
  • pollAfterSecondsinteger
  • urlstring
  • uploadsobject[]
  • stillTheirsstring
  • warningsstring[]
  • toobject
  • iconNotestring

Emits

pendingyou.request.posted

Rules and the person

list_rulesStanding answers to check before asking.

Query: only readsAssistant

What the assistant reads

The person’s standing rules. If one answers your question, follow it and post an fyi naming it.

Input

Field ? optionalTypeWhat it’s for
areaId?string

Example

list_rules · inputJSON
{
"areaId": "prj_inbox"
}

Returns

  • rulesobject[]
whoamiWho you are acting for, whether they’re muted, the newest skill.

Query: only readsAssistant

What the assistant reads

Who you act for, app.setUp, handoff.afterMinutes and the latest guide.

Input

Field ? optionalTypeWhat it’s for
skillVersion?stringThe guide revision you read ("1.5").
name?stringYour own name, or your task’s.
previousName?stringRenamed: the name you went by. Moves its open cards and webhook to name.
about?stringOne line: your role and current work, max 120 chars. "" clears it.
guide?booleantrue: also returns the guide and the stub to save.

Example

whoami · inputJSON
{}

Returns

  • workspaceIdstring
  • personobject
  • agentobject
  • serverstring
  • appobject
  • mutedboolean
  • mutedUntilISO datetime | "forever"
  • blockingStillNotifyboolean
  • handoffobject
  • alsoAskedobject
  • stillTheirsstring
  • goBetweenobject
  • skillobject
  • emailFooterobject
  • emailsobject
  • teammatesobject[]
  • introductionsobject[]
  • guideobject

Setup

report_setupSay what you set up: the skill revision, how you hear answers, and the recipes from Pending You you run.

Command: changes stateAssistant

What the assistant reads

Report what you actually set up. Not ready: tell the person what’s missing.

Input

Field ? optionalTypeWhat it’s for
source"claude-code" | "codex" | "cursor" | "gemini-cli" | "opencode" | "pi" | "grok" | "muse" | "chatgpt" | "claude" | "dots" | "other" | "webhook"The app you run in.
namestringYour own name ("Wren").
skillVersionstringThe guide revision you read.
skillSavedbooleanSaved for future conversations, not just this one.
hears"instant" | "every-15-min" | "hourly" | "while-working" | "by-hand"instant: a wake webhook or Claude Code’s pendingyou hold; every-15-min or hourly: a scheduled task you made.
schedule?stringThe check-in you made ("Hourly, 7 AM–9 PM"), if any.
missing?string[]Steps you couldn’t do, in plain words for the person.
accepts?("image" | "pdf" | "text")[]Omit for your app’s default.
recipes?object[]Recipes from Pending You you run, by slug; stopped true once you stop one.
recipestring
schedule?string
stopped?boolean

Example

report_setup · inputJSON
{
"source": "grok",
"name": "Wren",
"skillVersion": "1.5",
"skillSaved": true,
"hears": "hourly",
"schedule": "Every 3 hours, 7 AM–9 PM"
}

Returns

  • connectionIdstring
  • readyboolean
  • currentboolean
  • latestVersionstring
  • missingstring[]
  • testAreaIdstring
  • agentobject
  • recipesstring[]
  • warningsstring[]

Emits

pendingyou.connection.reportedpendingyou.connection.readypendingyou.connection.revokedpendingyou.project.createdpendingyou.project.archivedpendingyou.project.unarchivedpendingyou.agent.reportedpendingyou.recipe.reportedpendingyou.recipe.stopped
set_wake_webhookHand over your routine’s webhook, so an answer wakes you.

Command: changes stateAssistant

What the assistant reads

Hand over your routine’s webhook, so an answer wakes you (ids only; then get_request). Never put it in chat.

Input

Field ? optionalTypeWhat it’s for
urlstring
key?stringIf your app shows one separately.
header?stringThe header the key goes in, if named.
test?booleanSend one test wake.
name?stringYour name, to wake only you.

Example

set_wake_webhook · inputJSON
{
"url": "https://routines.example/hooks/pending-you"
}

Returns

  • connectionIdstring
  • agentIdstring
  • hears"instant"
  • testedboolean

Emits

pendingyou.connection.wake_setpendingyou.connection.readypendingyou.agent.wake_set

Helping

answer_delegatedAnswer a question your person delegated to you.

Command: changes stateAssistant

What the assistant reads

Answer a question your person handed you from another assistant, only if you know it, saying how you know. Never delegate it further.

Input

Field ? optionalTypeWhat it’s for
requestIdstring
name?string
expectedVersioninteger
choiceIds?string[]
approved?boolean
text?string
answers?mapA card with several questions: every question’s answer, by its id, each as its kind takes it.
whystringHow you know, in a sentence or two; they see it with your answer.
note?stringAnything else they should know; any answer.

Example

answer_delegated · inputJSON
{
"requestId": "req_aws-account",
"name": "infra",
"expectedVersion": 2,
"text": "recordplane-dev",
"why": "Staging and the preview stacks already live in recordplane-dev (cdk.context.json). assist-sandbox is for experiments."
}

Returns

  • requestIdstring
  • status"answered" | "pending" | "resolved"
  • versioninteger
  • warningsstring[]

Emits

pendingyou.request.answeredpendingyou.request.suggested
hand_backGive a delegated question back, with what you found.

Command: changes stateAssistant

What the assistant reads

Hand back a delegated question you can’t finish, with what you found and a reason: blocked (the asker can unblock you), needs_person or not_mine.

Input

Field ? optionalTypeWhat it’s for
requestIdstring
name?string
foundstringWhat you checked and found, so their answer is quicker.
reason?"blocked" | "needs_person" | "not_mine"
needs?stringWith blocked: what would unblock you.

Example

hand_back · inputJSON
{
"requestId": "req_caterer",
"name": "Muse",
"found": "Our household notes list one peanut allergy from the spring party. I don’t know this year’s guest list."
}

Returns

  • requestIdstring
  • status"delegated" | "pending"
  • versioninteger
  • goesTo"asker" | "person"
  • nextstring

Emits

pendingyou.request.handed_backpendingyou.request.talk_added
read_stackYour go-betweenRead your person their stack (go-between only).

Query: only readsYour go-between

What the assistant reads

Go-between only: everything pending your person, most urgent first. Read one at a time, in the asking assistant’s words.

Input

Field ? optionalTypeWhat it’s for
limit?integerHow many to read, most urgent first. Default 10.
cursor?stringFrom your last read_stack, to carry on where you stopped.

Example

read_stack · inputJSON
{
"limit": 5
}

Returns

  • requestsobject[]
  • hiddeninteger
  • cursorstring
relay_answerYour go-betweenPass on your person’s answer (go-between only).

Command: changes stateYour go-between

What the assistant reads

Go-between only: pass on what your person decided, in their words (said). High stakes: read it back, get a clear yes and set readBack; it still waits for their tap.

Input

Field ? optionalTypeWhat it’s for
requestIdstring
expectedVersioninteger
choiceIds?string[]
approved?boolean
text?string
saidstringWhat they said, word for word. It rides along as their note, so the asker hears it in their words.
via"voice" | "text"How they told you.
readBack?booleantrue when you read back an answer that sends, spends or can’t be undone, and they said yes.

Example

relay_answer · inputJSON
{
"requestId": "req_flight",
"expectedVersion": 1,
"choiceIds": ["a"],
"said": "The seven forty.",
"via": "voice"
}

Returns

  • requestIdstring
  • status"answered" | "needs-confirm"
  • versioninteger
  • shownAsstring

Emits

pendingyou.request.answered
delegate_requestYour go-between or youHand a question to another assistant that might know.

Command: changes stateYour go-between or you

What the assistant reads

Go-between only, when they ask: hand a question to another of their assistants. If they didn’t say whether it may answer freely, ask.

Input

Field ? optionalTypeWhat it’s for
requestIdstring
toobjectThe assistant, and for coding agents the running task, e.g. the infra session.
connectionIdstring
agentId?string
sessionId?string
mode"freely" | "loop"freely: it answers the asker directly. loop: its answer comes back first.
note?stringAnything it should know, in their words.
standing?true

Example

delegate_request · inputJSON
{
"requestId": "req_aws-account",
"to": {
"connectionId": "con_cc-studio",
"sessionId": "ses_infra"
},
"mode": "freely"
}

Returns

  • requestIdstring
  • status"delegated"
  • versioninteger
  • hears"instant" | "every-15-min" | "hourly" | "while-working" | "by-hand"
  • undoUntilISO datetime
  • returnAtISO datetime

Emits

pendingyou.request.delegatedpendingyou.request.postedpendingyou.project.createdpendingyou.request.picked_uppendingyou.introduction.madependingyou.introduction.standing_set
suggest_improvementTell the Pending You team what didn’t fit.

Command: changes stateAssistant

What the assistant reads

Tell the Pending You team what didn’t fit or slowed you down, never the person’s private details. Post your question the closest way first.

Input

Field ? optionalTypeWhat it’s for
about"kind" | "field" | "flow" | "setup" | "other"kind: a question no kind fits. field: a kind that needs another field. flow: how asking or hearing answers works. setup: connecting. other.
whatHappenedstringWhat you were trying to ask or do, and what didn’t fit. Describe it; never paste the person’s private details.
ideastringWhat would have worked, in a sentence or two.
requestId?stringThe question you posted the closest way you could, if any.
wouldHaveSent?mapFor a new kind or field: the JSON you would have sent, with made-up values.

Example

suggest_improvement · inputJSON
{
"about": "kind",
"whatHappened": "I needed my person to pick a meeting time from six free slots. I could only offer five options, so I dropped one.",
"idea": "A “pick a time” kind that shows free slots from their calendar, grouped by day.",
"requestId": "req_calendar",
"wouldHaveSent": {
"kind": "time",
"slots": ["2026-10-02T14:00", "2026-10-02T15:30", "2026-10-05T10:00"],
"durationMinutes": 45
}
}

Returns

  • ideaIdstring
  • heardBeforeinteger

Emits

pendingyou.idea.suggested

Other tools

get_attachmentAssistant or youRead an image or file on one of your requests.

Query: only readsAssistant or you

What the assistant reads

Open an image or file from an answer or message; a PDF comes as a downloadUrl.

Input

Field ? optionalTypeWhat it’s for
attachmentIdstring
name?string
inline?booleanPDF: also embed it (≤4 MB).

Example

get_attachment · inputJSON
{
"attachmentId": "att_0f3a9c2e7b1d4a6e8c05"
}

Returns

  • idstring
  • place"card" | "message" | "answer"
  • messageIdstring
  • by"you" | "agent"
  • status"waiting" | "ready" | "failed" | "removed"
  • titlestring
  • contentType"image/jpeg" | "image/png" | "image/webp" | "application/pdf" | "text/plain" | "text/csv" | "text/markdown" | "application/json"
  • widthinteger
  • heightinteger
  • bytesinteger
  • createdAtISO datetime
  • removedAtISO datetime
  • requestIdstring
  • blobKeystring
  • notestring
Only you can answer
answer_request, snooze_request and create_rule are app-only. They’re never exposed as MCP tools, and the capability rejects them from anyone acting through an assistant. 16 more run on timers.