Hark began with a tiny, obvious contract: send a webhook and get a useful notification on my iPhone. The first version supported a custom image, a link to open on tap, a title, and a description. That was enough to turn output from a script or service into something I would actually see away from my desk.

The demo traveled much further than I expected. The 2,268 bookmarks mattered more to me than the likes: people wanted a way to connect their own tools to the phone in their pocket.

The webhook was the right starting point

A webhook keeps the sending side simple. The caller does not need to understand the notification app. It only needs somewhere to send a request and a small set of values describing what should appear.

That boundary made Hark useful to more than one category of software. A CI job can have an event worth seeing. A monitor can have a state worth surfacing. A coding agent can finish a task while I am away. The notification can carry enough context to tell those sources apart, and its link can take me back to the place where the next action belongs.

The first release only moved information in one direction. A system could get my attention, but I still needed to leave the notification and find another interface to do anything about it. That limitation became the next version of Hark.

From alerts to interaction

I added three pieces together: notification responses, custom Live Activities, and a CLI for agents and workflows.

Responses let a notification ask for text or present options. Live Activities let a webhook control information that should remain visible and change over time. The CLI gave an agent a direct way to use both without forcing it through a complicated product-specific interface.

The layouts stayed deliberately flexible. Hark shipped with five Live Activity layouts, with custom text, colors, and icons controlled through webhooks and the CLI. I did not want my choice of layout to become everyone else's permanent limitation, so the open-source project can accept more.

That agent-facing layer matters because software built for agents can become strangely difficult. A capability may exist, yet still demand enough setup and translation that an agent cannot use it cleanly. The Hark CLI and skill make the available actions explicit: send the notification, collect a response, or control a Live Activity.

The demo of an agent sending a notification and updating a Live Activity is the compact version of that idea. Hark is still a phone interface, but the caller can be an automated workflow rather than a person clicking through a dashboard.

The remote approval that made it real

The best test happened while I was away from my machine. I needed to publish a new NPM version, and that process required a passkey. I had the agent start the publish, then send its authentication URL to me as a Hark notification. I opened the URL on my phone and approved it there.

That workflow is small, but it draws a useful security boundary. The agent could perform the work it was equipped to perform. When the process reached an approval tied to me, it did not need my credential or a fake shortcut around the check. It handed the decision to my phone.

This is the shape I wanted: automation continues until it reaches a moment that genuinely needs a person, then that moment arrives with enough context to act. The notification is no longer the end of the workflow. It is the handoff between the agent and me.

Open source and self-hostable

Notifications can contain sensitive information, and an approval channel deserves scrutiny. I made Hark open source so people can inspect the project, contribute features, and self-host it if that is the right trust model for their work.

Sign in with Apple was added as the product expanded, but the larger principle stayed the same: Hark should remain understandable at its boundaries. A source sends a webhook or uses the CLI. The phone presents information or collects an explicit response. The source continues with that response.

You can try Hark at hark.ryan.ceo or inspect the open-source project. Hark gives scripts and agents a clear, interruptible path to a human when the work actually calls for one.