Human-in-the-loop over MCP

Human-in-the-loop over MCP, with one config entry.

Point any MCP client at the hosted Pushary server, and your agent can ask a person. Nothing to install.

Try it on your phone

What MCP gives you

Elicitation, where the client supports it

The MCP spec lets a server ask the user something in the middle of a call. The server sends an elicitation request, the client shows it, and the answer comes back. When the client supports it and the person is at that client, use it.

native
// Server asks the host to collect an answer.
// Works only if THIS client implements elicitation,
// and only while the user is actually looking at it.

Where it stops

  • Client support is uneven, so a server that relies on it behaves differently in every host.
  • It reaches whoever is at the client now. If they walked away, nothing happens until they return.
  • There is no record afterwards. The answer goes into the conversation and nowhere else.

The fix

Pushary gets your user's answer.

MCP gives your agent tools, and no MCP client ships a way to reach someone away from the keyboard. With the hosted server, ask_user sends the question to a phone, wait_for_answer returns the reply, and every answer is saved.

Add this entry to your MCP client with your API key as a Bearer token. Your agent gets ask_user, wait_for_answer, send_notification and cancel_question. On the Partner plan, four more tools connect your own users and ask them about their own actions.

No install. One MCP server entry.

config
{
  "mcpServers": {
    "pushary": {
      "type": "http",
      "url": "https://pushary.com/api/mcp/mcp",
      "headers": { "Authorization": "Bearer YOUR_PUSHARY_API_KEY" }
    }
  }
}

How it works

From install to the first answer

Connect your user once. Put the approval on the risky step. Pushary sends the question, waits for the answer and saves it.

  1. 01

    Add the server entry

    Add the Pushary entry to your client's MCP config with your API key as a Bearer token. That is the whole setup.

  2. 02

    Connect your phone

    Connect your phone to your Pushary workspace once. On the Partner plan, one tool call returns a connect link for each of your own users.

  3. 03

    Let the agent ask

    The model calls ask_user when it needs a decision and wait_for_answer to hold for the reply. send_notification covers finished tasks and errors.

  4. 04

    Treat no answer as no

    If wait_for_answer says nobody answered, the agent stops. The question expires and never turns into a yes.

A question can be a yes or no, a choice from a list, or a typed answer. Every answer is saved.

Before you ship

Things that bite on MCP

Notify and gate are not the same thing
A tool the model chooses to call is optional. A model that does not want to be interrupted can skip it, and a prompt that says “ask first” does not change that. If an action must not happen without a yes, the gate goes in front of execution: on CLI agents, a PreToolUse hook.
The MCP timeout is not your approval window
Hosts cancel long tool calls on their own schedule, often in under a minute. A blocking ask that outlives the host's timeout gets cancelled in the client, while the question is still open and answerable on the phone.
Every host names and shows tools differently
The same server appears with different tool descriptions and approval prompts in each client. Test the ask flow in every host you support, because the wording the model sees changes whether it calls the tool at all.

The Partner plan

Your agent asks your users, not just you

Ship your agent to your users. Each of them approves its risky actions from their phone, under your brand.

$99/ month, every framework included
Start free

Your users never make a Pushary account or pay us.

Your users answer on their own phones

Connect each user once with a link. They install the free Pushary app and answer from the lock screen, with no account of their own.

No answer means no

Run the action only after an explicit Approve. A request that is still waiting, expired or cancelled never counts as a yes. Pushary keeps every request, so your code can pick it up again after a restart.

Reaches them on their phone

The app comes first, because only the app puts Approve and Deny on the lock screen. Browser notifications come next. You build no delivery system.

Every answer saved

Every answer is saved with who answered and when. You can search and export it, and with a callback URL, each answer is also sent to your server as a signed webhook.

FAQ

Questions, answered

What tools does the hosted MCP server expose?
The core tools are ask_user for questions (yes or no, a choice, or typed text), wait_for_answer to hold for the reply, send_notification for alerts, and cancel_question to take a question back. Partner-plan keys also get enroll_end_user, create_decision, get_decision and cancel_decision, which ask your own users and keep each answer.
Who receives the question?
The phones connected to your Pushary workspace, so you and your team. To reach your own users about their own actions, use the Partner-plan tools that connect a user and create a decision, or the same two calls from @pushary/server or pip install pushary.
Do I need to install anything?
No. The server is hosted at https://pushary.com/api/mcp/mcp. Add one config entry with your API key as a Bearer token, and the tools appear in your client.
Which clients does it work with?
Any MCP client that supports remote HTTP servers, including Claude Code, Cursor, the Claude Agent SDK, the OpenAI Agents SDK's MCP support and LangChain's MCP adapters.
What happens if nobody answers in time?
The question expires and wait_for_answer says so. Treat that as no, so the agent does not take the action.
How is this different from MCP elicitation?
Elicitation asks whoever is at the client right now; Pushary reaches a phone. Use elicitation when the person is in front of the client. Its client support is uneven, and it does nothing for someone who walked away. Pushary keeps the question through a restart, counts no answer as no, and saves the answer. Elicit when the user is present, ask Pushary when they are not.
Can I make an MCP tool call require approval?
Not with a tool alone. A tool the model chooses to call is optional, and a model can decline to call it. A real gate sits in front of the action, which on CLI agents means a PreToolUse hook. Over plain MCP you get a habit and a record, not a gate. If the action must never run without a yes, use a hook.

Let your MCP agent ask before it acts.

Connect a user once, ask with one call, and run the action only on a yes. Every answer is saved.

Start free

Partner plan, $99 a month. Your users never make a Pushary account or pay us.

Human-in-the-loop for other frameworks

All frameworksSee the Partner planHuman-in-the-loop docsWhat human-in-the-loop meansEmbed in your productVercel AI SDKLangGraphCrewAIOpenAI Agents SDKEveMastraLangChainClaude Agent SDKHermesOpenClawn8n