What is human-in-the-loop for AI agents?

Human-in-the-loop means an autonomous AI agent pauses at a decision point and asks a person to approve, deny, or answer before it continues. Pushary delivers that question as a push notification to your phone, so you can respond in one tap from your lock screen and the agent picks up your answer and keeps going.

Which AI agents does Pushary work with?

Any agent that can call a tool over MCP or make an HTTP request. That includes coding agents like Claude Code, Codex, Cursor, and Hermes, and just as well n8n, Zapier, Make, LangChain or LangGraph agents, and custom Python or TypeScript agents. If your agent can call ask_user or hit the Pushary API, it can ask you for a decision.

Can I add a human approval step to my n8n or automation?

Yes. Your n8n, Zapier, or Make workflow calls Pushary to ask a question, you get a push on your phone, and the workflow resumes when you answer. The answer comes back through polling or a signed webhook callback, so the automation continues with your decision. This is a notify-and-wait checkpoint, not an enforced block on the runtime.

Does my agent need to be a coding agent?

No. The core job, push a question to your phone and wait for the answer, works with any MCP or API agent, coding or not. Coding agents that support hooks (Claude Code, Codex, Hermes, Cursor) get more: one-command setup and enforced permission gating that can hard-block a command until you approve. Other agents get the human-in-the-loop pause and notifications, not an out-of-the-box runtime block.

How does my agent send a question to my phone?

Two ways. Over MCP, your agent calls the ask_user tool with the question and option type, then polls wait_for_answer until you respond. Over the API, your agent posts the question and provides a callback URL; Pushary delivers a signed webhook to that URL with your answer when you tap. Either way Pushary sends the push and routes your decision back.

Is my data sent to Pushary?

Only the notification metadata your agent chooses to send: the question text, the options, the agent name, and a correlation ID. Your code, files, and the rest of your agent run stay where they are. Pushary holds the pending question just long enough to deliver the push and route your answer back.

Menselijke beslissingen voor AI-agenten

Your AI agent needs a human. Answer from your phone.

Met Pushary kunnen AI-agenten een mens om een beslissing vragen. Je agent pauzeert, jij keurt goed, wijst af of antwoordt vanaf je telefoon. Daarna gaat hij verder met je antwoord.

Start je proefperiode

Leesbare gegevens blijven tot het minimum beperkt. Gesynchroniseerde transcripties worden versleuteld vóór verzending naar je telefoon en voor het gedocumenteerde herstel door Pushary voor compliancedoeleinden.

$ claude refactor auth/ --apply

rewrote session + token refresh

12 files changed, tests passing

Tap to answer

Voor elke agent die een tool kan aanroepen

Gebruikt je agent MCP of kan hij een HTTP-verzoek doen? Dan kan hij jou om een beslissing vragen en op het antwoord wachten. Zonder vast te zitten aan een framework of alles te herschrijven.

De basis: melden en wachten

Elke MCP- of API-agent kan met ask_user een vraag stellen en het antwoord via wait_for_answer of een ondertekende webhook ontvangen. Dat werkt met Claude Code, Codex, Cursor en Hermes, maar ook met n8n, Zapier, Make, LangChain, LangGraph en je eigen Python- of TypeScript-agenten.

Codeeragenten kunnen ook de uitvoering blokkeren

Een harde blokkade vóór uitvoering, tot jij een opdracht goedkeurt, werkt bij codeeragenten met hooks: Claude Code, Codex, Hermes en Cursor. Algemene MCP- en API-agenten krijgen meldingen en wachten op een menselijk antwoord. Ze hebben niet standaard zo'n blokkade in de runtime.

Claude CodeCodexCursorHermesn8nZapierMakeLangChainLangGraphEigen Python- / TS-agenten

Zo werkt het

In drie stappen weer verder

De agent blijft niet wachten op een scherm waar je niet naar kijkt. Hij vraagt, jij antwoordt, hij gaat verder.

01
Je agent heeft een beslissing nodig
Tijdens het werk komt je agent iets tegen waar een mens over moet beslissen: een riskante actie, ontbrekende informatie of een goedkeuring. Hij roept ask_user via MCP of de Pushary-API aan in plaats van te gokken.
02
De vraag komt op je telefoon
Pushary toont de precieze vraag, de naam van de agent en de keuzes op je vergrendelscherm. Keur goed, wijs af of typ een antwoord. Je hoeft niet door een app te bladeren of een terminal in de gaten te houden.
03
Je antwoord komt terug, de agent gaat verder
De agent krijgt je antwoord door wait_for_answer op te vragen of via een ondertekende webhook. Daarna gaat hij verder met jouw beslissing. Antwoord je niet op tijd, dan geldt je ingestelde time-outregel.

Er zijn drie vraagtypen: ja of nee met confirm, meerkeuze met select en vrije tekst met input. Elke beslissing komt in een onveranderbaar auditlog dat je later kunt bekijken.

Waar je het voor kunt gebruiken

Concrete goedkeuringsstappen voor agenten die echte acties uitvoeren, niet alleen code schrijven.

Een riskante beheeractie goedkeuren

Een Ops- of DevOps-agent wil iets deployen, een record verwijderen of geld uitgeven. Laat hem eerst vragen en keur de actie vanaf je telefoon goed of af. Codeeragenten met hooks kunnen de uitvoering daadwerkelijk blokkeren. Andere agenten pauzeren bij ask_user en wachten op je antwoord.

Een menselijke goedkeuring toevoegen aan een automatisering

Voeg een goedkeuringsstap toe aan een n8n-, Zapier- of Make-workflow. De automatisering roept Pushary aan, je krijgt een pushmelding en je antwoord hervat de workflow via een webhook. Je team hoeft geen nieuw dashboard te leren gebruiken.

Goedkeuren voordat een agent een klant benadert

Voordat een onderzoeks- of verkoopagent een klant mailt, een kaart belast of iets publiceert, krijg je het voorstel op je telefoon voor een ja of nee. De agent wacht op je akkoord en verstuurt het daarna.

Een melding krijgen als een lange taak klaar is of mislukt

Start een lange autonome taak en ga iets anders doen. Pushary meldt wanneer de taak klaar is of vastloopt. Je hoeft niet een uur lang op een terminal te letten.

Voor codeeragenten

Werk je met codeeragenten? Dan krijg je meer controle.

Met Claude Code, Codex, Cursor of Hermes gaat Pushary verder dan melden en wachten: je houdt controle over de uitvoering.

Read the quickstart

Instellen met één opdracht
Eén opdracht installeert de hook in de agent die je al gebruikt. Ongeveer twee minuten, zonder code te schrijven.
Blokkeren tot je goedkeurt
Een riskante opdracht blijft geblokkeerd totdat je hem vanaf je telefoon goedkeurt. Een echte blokkade waar de agent niet voorbij kan, in plaats van een melding die je kunt missen.
Regels en audit op één plek
Stel per tool eenmalig regels in via de browser: automatisch goedkeuren, afwijzen, doorsturen of een time-out. Bewaar alle beslissingen van je agenten in één onveranderbaar auditlog.

Veelgestelde vragen

Vragen en antwoorden

Wat betekent human-in-the-loop voor AI-agenten?

Een autonome AI-agent pauzeert bij een beslissing en vraagt een mens om goedkeuring, afwijzing of een antwoord voordat hij doorgaat. Pushary stuurt die vraag als pushmelding naar je telefoon. Je antwoordt vanaf je vergrendelscherm en de agent gaat verder met je antwoord.

Met welke AI-agenten werkt Pushary?

Met elke agent die een tool via MCP kan aanroepen of een HTTP-verzoek kan doen. Denk aan Claude Code, Codex, Cursor en Hermes, maar ook n8n, Zapier, Make, LangChain, LangGraph en eigen Python- of TypeScript-agenten. Als je agent ask_user of de Pushary-API kan aanroepen, kan hij jou om een beslissing vragen.

Kan ik een menselijke goedkeuringsstap toevoegen aan n8n of mijn automatisering?

Ja. Je n8n-, Zapier- of Make-workflow stelt via Pushary een vraag. Je krijgt een pushmelding en de workflow gaat verder zodra je antwoordt. Het antwoord komt via polling of een ondertekende webhook terug. Dit is een stap die meldt en wacht, geen afgedwongen blokkade van de runtime.

Moet mijn agent een codeeragent zijn?

Nee. Een vraag naar je telefoon sturen en op het antwoord wachten werkt met elke MCP- of API-agent. Codeeragenten met hooks, zoals Claude Code, Codex, Hermes en Cursor, bieden ook installatie met één opdracht en een harde blokkade tot je goedkeurt. Andere agenten krijgen de pauze en meldingen, zonder ingebouwde runtimeblokkade.

Hoe stuurt mijn agent een vraag naar mijn telefoon?

Dat kan op twee manieren. Via MCP roept je agent ask_user aan met de vraag en het vraagtype, en vraagt daarna wait_for_answer op totdat je antwoordt. Via de API verstuurt hij de vraag met een callback-URL. Pushary stuurt je antwoord als ondertekende webhook naar die URL. In beide gevallen bezorgt Pushary de melding en stuurt je beslissing terug.

Worden mijn gegevens naar Pushary gestuurd?

Alleen de meldingsgegevens die je agent verstuurt: de vraag, de opties, de naam van de agent en een correlatie-ID. Je code, bestanden en de rest van de uitvoering blijven waar ze zijn. Pushary bewaart de openstaande vraag zolang dat nodig is om de melding te bezorgen en je antwoord terug te sturen.

Manifest

De beslissingen achter AI-agenten

Pushary wil de standaard worden voor beslissingen bij AI-agenten. Agenten gaan meer werk doen. Mensen blijven beslissen. Dat zijn de principes waarop we bouwen.

Lees het Pushary-manifest

Geef je agent een manier om het te vragen.

Ontvang een vraag op je telefoon, antwoord met één tik en laat de agent het werk afmaken terwijl je weg bent. Werkt met elke MCP- of API-agent.

Start your trial

Liever eerst de code zien? Lees de snelstartgids.