Is there a LangGraph package for Pushary?

Yes. pushary-langgraph for Python and @pushary/langgraph for TypeScript. Each gives you connect(), a blocking ask_human, and pushary_interrupt that wraps LangGraph's own interrupt() for the durable path.

Should I use ask_human or pushary_interrupt?

Use ask_human for a straightforward approval that resolves in under a minute. Use pushary_interrupt with a callback_url when the wait can be long: it parks the graph in your checkpointer and resumes from a signed webhook, so it holds no compute.

What happens if nobody answers?

The decision comes back denied. Anything that is not an explicit approval fails closed, so the graph does not take the guarded action, and the durable ledger keeps the request across restarts.

Can my own end-users approve on their own phones?

Yes. The external_id is your own id for the user, connected once with a one-tap link. Each user gets their own approval on their own phone, with no account or app on their side.

Does this work with plain LangChain agents?

Yes. ask_human is a normal function, so you can put it in any LangChain tool or callback the same way you put it in a LangGraph node.

Human-in-the-loop for LangGraph and LangChain

Human-in-the-loop for LangGraph agents, answered on a phone.

A LangGraph node asks a real person and blocks, or parks on a durable interrupt until they answer.

The integration

Add it to your LangGraph agent

Install pushary-langgraph, or @pushary/langgraph in TypeScript. It gives a LangGraph node two ways to ask a real person. ask_human blocks right there until they answer. pushary_interrupt parks the graph with LangGraph's own interrupt() and resumes when a signed webhook comes back, so a long wait holds no compute. Both send the question to a phone, fail closed if nobody answers, and record every decision in a durable ledger. The external_id is your own id for the end-user, so each person approves their own action.

pip install pushary-langgraphtwo calls

from pushary_langgraph import connect, ask_human

# Connect the user's phone once, keyed to your own id.
connect("user_123")

# Ask a human from inside a LangGraph node. Blocks until they answer, fail-closed.
def approve_transfer(state):
    d = ask_human("Approve this transfer?", external_id=state["user_id"], node="approval")
    return {"approved": d["approved"]}

Why you need it

LangGraph pauses the agent. Pushary reaches the human.

LangGraph's interrupt() pauses a node and saves its state, and it does not notify anyone or carry the decision to a phone. pushary-langgraph fills that gap. pushary_interrupt opens the decision, delivers it to the person, parks the graph, and resumes on a signed webhook, while ask_human covers the simpler blocking case. Both are fail-closed and both write to a durable ledger, so a restart never loses the request. The external_id is your own end-user, so each person approves their own action.

How it works

From ask to resume

Connect the phone once, then ask a human from the tool or step that guards the action. The waiting, the delivery, and the record are handled for you.

01
Install the adapter
Add the package: pip install pushary-langgraph for Python, or npm i @pushary/langgraph for TypeScript. Set your Pushary API key in the environment.
02
Connect the phone
Call connect(external_id) once per end-user. It returns a link the person taps once to turn on approvals, with no account and no app to install.
03
Ask a human in a node
For a quick wait, call ask_human() inside the node that guards the action. For a long wait, call pushary_interrupt() with a callback_url to park the graph and resume it from the webhook.
04
Continue on the answer
The answer is fail-closed: a decline, a timeout, or no reply all count as not approved, so the graph never takes the guarded step on silence. Every decision is kept in the audit log.

A decision is a yes or no confirm, a multiple-choice select, or a free-text input. Every one is stored with its outcome and kept in the audit log.

The Partner plan

Your agent asks your users, not just you

Ship the agent to real users and let each of them approve their own decisions from their phone, under your brand.

$99/ month, every framework included

Your users never see a Pushary login or bill.

Your users answer on their own phones

The externalId is your own id for the end-user. Connect their phone once with a keyless one-tap link, and every approval lands with the right person. No account, no app, no key on their side.

Durable, fail-closed waits

The agent stays open on a durable wait backed by a decisions ledger. If nobody answers in the window you set, the decision comes back denied, so a timeout or a restart never turns into an unapproved action.

Phone-first delivery

Pushary reaches the person on the device they carry: native app push first, then PWA push notifications, then Slack if you route it there. You do not build a delivery pipeline.

Signed webhooks and an audit trail

Every decision is written to a durable ledger you can query and export, and resolved decisions post a signed webhook to your callback URL. You have the record of who approved what and when.

FAQ

Questions, answered

Human-in-the-loop for other frameworks

All frameworks Human-in-the-loop docs What human-in-the-loop means Embed in your product Vercel AI SDK CrewAI OpenAI Agents SDK Eve Mastra LangChain MCP Claude Agent SDK Hermes OpenClaw

Let your LangGraph agent ask a human.

Connect a user with one tap, ask a human with one call, and act on a fail-closed decision. Every decision is saved to a durable ledger you can audit.

Partner plan, $99 a month. Your users never see a Pushary login or bill.