The Partner plan
Give your users the final say, on their phone.
Embed Pushary and the people who use your product approve your agent's risky steps from their own lock screen.
@pushary/server · @pushary/ai-sdk · @pushary/eve · pip install pushary
How do I add human approval to an AI product my customers use?
Pushary is a managed human-in-the-loop layer built for companies shipping an AI agent to their own customers. enroll(externalId) maps your own user id to that person's phone with one keyless tap, and decisions.ask() blocks your agent until they approve, deny, or answer. You do not build the delivery pipeline, the durable wait, the timeout policy, or the audit log.
The moment
Your agent is about to spend someone else's money
Everything your agent does that is reversible can keep running unattended. Then it reaches a refund, an outbound message to a named client, a deletion, a payment. The model can propose that action, and the person whose money or data it touches should be the one who agrees to it. In a product with real customers, that person is not you.
What that costs
You can build this. Here is what it is.
None of these parts is hard on its own. Together they are a distributed systems project sitting in the middle of the product you meant to be shipping.
- Reaching the person
- A delivery path to a phone that works when the person is not at a desk, with a fallback when the first channel fails.
- Connecting a user
- An enrollment flow for someone who has no account with you and no reason to install anything.
- Waiting
- A wait that holds across a deploy or a crash, rather than an in-memory promise that dies with the process.
- Timing out
- A timeout that denies instead of assuming yes, and a way to tell the two apart afterwards.
- The record
- A queryable store of who was asked, what they saw, what they chose, and when.
- The page they answer on
- A decide surface that carries your brand, because it is your customer looking at it.
Instead
Two calls, and your product can ask its users
The same code runs for one user or a hundred thousand. Each person is addressed by the id you already have for them.
Everything in the list above is already running behind these two lines.
import { createPusharyServer } from "@pushary/server"
const px = createPusharyServer({ apiKey: process.env.PUSHARY_API_KEY! })
// Connect one of your users. Your id, their phone, one keyless tap.
await px.enroll(user.id)
// Ask that specific person. Blocks until they decide.
const decision = await px.decisions.ask({
externalId: user.id,
type: "confirm",
question: "Approve a $480 refund to customer #4471?",
})
if (decision.approved) await issueRefund()What you get
Built for the person who is not you
Every part of this assumes the approver is your customer rather than an engineer on your team.
Your users, not just you
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, and no key on their side.
Durable waits that fail closed
The agent stays open on a wait backed by the decisions ledger. If nobody answers inside your window the call comes back denied, so a timeout or a restart never turns into an unapproved action.
A decide page under your brand
The person answering is your customer, so the page they land on carries your name and not ours. They never see a Pushary login, and they never get a Pushary bill.
Signed webhooks and an exportable ledger
Every decision is written to a durable ledger you can query and export, and resolved decisions post a signed webhook to your callback URL. The record of who approved what is there without you keeping it.
Three ways this gets used
You ship an AI agent to customers
Your product takes actions on a customer's behalf, and some of those actions should not happen without that specific customer saying yes. Refunds, outbound messages, record deletions, anything that moves money. Pushary asks the person whose data or money is on the line, and returns their answer to your agent.
You build agents for clients
Every client build repeats the same approval plumbing, and it is never the part you quoted for. Embedding Pushary once removes it from the estimate on every project after this one, and each client keeps their own workspace and their own branding on the decide page.
You run a platform other people build on
Your users are building agents that need a human step, and right now they each solve it badly on their own. A Pushary integration gives all of them the same approval primitive without you building one into the platform.
Building across several client projects, or fronting a platform other people build on? Tell us the shape and we will price it with you.
Pricing
One plan for embedding it
Priced for a company putting this inside a product, with room to grow into before anything has to change.
Introductory price
The standard price for the Partner plan is $299 a month. Accounts that start now keep $99 for as long as they stay subscribed.
Your users never see a Pushary login or bill.
Scale
- Connected end-users
- 25,000
- Decisions a month
- 100,000
- Team members
- 10
- Decision history
- 365 days
Included
- Embed in your own product
- Whitelabel decide page
- Signed webhooks
- Server and Python SDKs
- Exportable decisions ledger
FAQ
Questions, answered
How do I add human approval to an AI product my customers use?
Do my end-users need a Pushary account or an app?
How is this different from a notification API like Knock or Novu?
How is this different from HumanLayer?
What happens if the person never answers?
What is included in the $99 Partner plan?
Which frameworks does this work with?
I build agents for several clients. Do I need one plan each?
Let your users answer for themselves.
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. Card details are collected at checkout.