Honest comparison
Novu is open-source notification infrastructure that grew a conversational agent platform, with approve/deny cards on tool calls inside those conversations. Pushary is a standalone decision loop: any agent, anywhere, calls decisions.ask() and blocks until a person answers on their phone, fail-closed.
This comparison is unusually honest territory, because Novu ships a real approval primitive. The question is where your agent lives. If it is a conversational agent inside a Novu-run thread on Slack, Teams, WhatsApp, or Telegram, Novu's cards gate its tools where the conversation already is. If your agent is a LangGraph workflow, a Vercel AI SDK loop, a CrewAI crew, or a coding agent, there is no Novu conversation to post a card into, and what you need is a call that creates a decision, reaches the right person, blocks, and returns the answer. That call is Pushary.
Novu's own docs describe the mechanics: requesting tool approval posts the card and ends the turn, and the decision arrives later in a separate handler. That fits a chat runtime. Code that is mid-workflow wants the opposite shape: decisions.ask() blocks where it is called and hands back the answer, so the next line of your function is the decision being acted on, and a restart resumes the wait from the ledger.
In Novu's documented model, a pending approval is denied when the user sends a new message, and no expiry or reminder policy is documented for a card that simply goes unanswered. Pushary puts silence on a clock you set: the window closes, the decision resolves as not approved, the agent is told, and the expiry is written down. For refunds and deletes, that determinism is the feature.
Cards carry two buttons. Real oversight often needs more: pick which environment to roll back, choose a refund amount, type the sentence the agent should send. Pushary decisions carry confirm, select, and input types, and the person answers from the lock screen of a phone they connected once with a keyless tap, keyed to your own externalId.
Novu's notification core is open source with a large community, self-hosting is real, and the in-app Inbox component is the fastest way to ship a notification center. Novu Connect genuinely solves hard plumbing for conversational agents: webhook ingestion, identity resolution, and one thread across channels. If your agent is a chat participant, or open source is a requirement, Novu deserves the evaluation. Pushary's lane is the out-of-band decision, keyed to a person rather than a conversation.
| Feature | Pushary | Novu |
|---|---|---|
| Blocking call that returns the human's answer to waiting codeCORE | ||
| Works for agents running anywhere (not only inside a conversation) | ||
| Fail-closed timeout policy, documented and enforced | ||
| Confirm, multiple-choice, and free-text decisions | ||
| Keyless one-tap end-user phone enrollmentENROLL | ||
| Queryable decisions resource in the API | ||
| Approve/deny cards on agent tool calls | ||
| Two-way agent conversations in Slack, Teams, WhatsApp, Telegram | ||
| Embeddable in-app notification inbox | ||
| Open-source notification core, self-hostable | ||
| Pricing | Partner $99/mo, public and self-serve | Free tiers + usage-based (see their pricing) |
Competitor rows reflect Novu's public docs and pricing pages as of July 2026. Their agent platform is new and moving fast, so check their docs for current state.
Yes, and it is real: inside a Novu-run agent conversation, setting needsApproval on a tool (or calling ctx.toolApproval.request in a custom-code agent) posts an approve/deny card into the user's channel and pauses the agent's turn. The decision then arrives in a separate handler invocation. The shape is the difference: it is a turn-based pause inside Novu's conversation runtime, while Pushary's decisions.ask() is a standalone call any agent anywhere can make, which blocks and returns the answer to the waiting code.
Novu's documented tool approval is binary: approve or deny on the card. Pushary decisions can be a yes-or-no confirm, a multiple-choice select, or free-text input, so the human can pick a rollback target or type an instruction, and the answer flows back into the agent loop.
Pushary fails closed on a documented window: no answer resolves to not approved and the expiry is recorded in the ledger. Novu's tool-approval docs do not document a timeout, reminder, or expiry policy for a pending card, and a new user message in the conversation auto-denies pending approvals, which ties the outcome to conversation activity rather than to a clock you set.
Novu records the decision in the conversation context (ctx.history), and its dashboard shows conversation history and tool activity; its REST API reference documents no decisions resource to query. Pushary writes every question and answer to a decisions ledger you can read by id through the API, with signed webhooks pushing each resolution to your backend.
Two clear cases. If you want open-source notification infrastructure (multi-channel workflows, digest and delay steps, an embeddable inbox) with self-hosting on the table, Novu is a strong pick. And if you are building a conversational agent that lives in Slack, Teams, WhatsApp, or Telegram, Novu Connect genuinely solves channel plumbing, identity resolution, and threading, with approval cards included. Pushary is the right choice when the agent is not a chat participant: a workflow, a coding agent, or a product feature that must stop, reach a specific person on their phone, and act on a fail-closed answer.
enroll(externalId) connects the phone. decisions.ask() blocks on the answer, fail-closed, with every outcome in a durable ledger. Works with the Vercel AI SDK, LangGraph, CrewAI, Mastra, the OpenAI Agents SDK, Eve, Hermes, and MCP.
