Beyond the terminal

One front door.
A whole house behind it.

The terminal is what we lead with. It’s also one room. Push has been growing for two years across phones, browsers, and Macs — and the parts you don’t see at push.computer are the parts that make the terminal worth living in.

This is the longer read: what is actually in the box, what is shipping, and what is not polished yet.

The shape

Captures from anywhere.
Run on your Mac.
Review wherever you are.

Push isn’t a single app. It’s a small system — three surfaces and a road between them. Each surface is shaped by where it sits in your day.

iPhone

voice capture

Browser

webpage capture

push-relay

Cloudflare Worker · *.push-relay.com
Mac · your machine

The home.

server orchestration loop, embedded Postgres, nine runtime adapters

terminal the surface you saw on the front

feed agents asking you for what they need

surfaces sessions, issues, files, agents, skills

Phone captures voice. Browser captures pages. Both reach your Mac through the relay. Your Mac runs the agents and stores the work. The terminal is one of the rooms inside.

The home

Your Mac is where the work runs.
Everything else feeds into it.

In Full mode, your Mac runs a small server bound to 127.0.0.1:3100. That server schedules agents, holds your sessions in an embedded Postgres, serves the surfaces you click around in, and exposes a tunnel back to the relay so your phone and browser can reach the same machine they always could.

The orchestration loop is a 30-second heartbeat. Every half-minute the server scans for queued runs and dispatches them through one of nine runtime adapters. Adapters are the thin bridges between “a row in your database” and “a process running on your computer.”

Runtime adapters
claude_localcodex_localcursorgemini_localopencode_localopenclaw_gatewaypi_localprocesshttp

The first six are agent CLIs. The last three are escape hatches — process shells out to any binary you can run on a Mac; http reaches anything with a webhook.

Around the Feed

Terminal

What you saw on the front. Lives in both modes.

Sessions

Every agent run, queued, running, completed, failed. The audit log of what happened.

Feed

The room where agents ask for approvals, reviews, and choices that need a human.

Issues

Work tracking from captures, terminal sessions, or the agents themselves.

Files

Whatever agents produce, plus anything you open from a terminal pane.

Agents

Each configuration: runtime, workspace, prompt, and cadence.

Skills

Push-shipped, user-defined, and agent-taught actions.

Two more — Memory and Costs — sit behind experimental flags. Both work; neither is final.

Why local?

Your code is on this machine. Your secrets are on this machine. Your transcripts and session histories should stay on this machine too. The Mac is the home because the home is where the data lives.

The road

The relay is a road,
not a destination.

push-relay is a Cloudflare Worker. When you sign in with your Apple ID on the Mac, the relay mints you a stable subdomain — something like skl1l.push-relay.com — and a tunnel opens between your Mac and the Worker.

That’s it. The relay doesn’t store your data. It tunnels HTTP and WebSocket frames between your phone, your browser, and your Mac. It also signs Apple Push Notifications so your phone knows when an agent is asking for you.

Subdomains rotate the way a DNS lease rotates: yours stays yours unless you sign out and back in with a different Apple ID, in which case the old one is tombstoned and you get a new one. Hardware fingerprint locks the tunnel to your machine.

The relay matters because without it, your phone and your Mac cannot reliably find each other across networks. With it, they can — without ever going through anyone’s SaaS.

The phone

A voice memo from anywhere.
A task in the right place before you put your phone down.

Push iOS is a capture surface, not a control panel. Hold the button, talk for thirty seconds, and the app does the rest.

  1. 01

    Records

    Audio to disk. A Live Activity in the Dynamic Island shows elapsed time and a finishing-up state when you are done.

  2. 02

    Transcribes

    On iOS 26 with Apple Intelligence, whisper.cpp runs on the Neural Engine — fully on-device. Older devices fall back to cloud transcription.

  3. 03

    Extracts

    Apple Foundation Models pull structure from the transcript: title, summary, implied due date, and the right destination.

  4. 04

    Routes

    The structured task goes through the relay to your Mac. Within a heartbeat, the right adapter picks it up and runs.

Six destinations from the phone today
Claude CodeCodexOpenClawGitHub issueLinear tasktodo list

There’s a hands-free mode for thinking out loud, AirPods triggering for walking, a Live Activity for the lock screen, and a widget for today’s count. The novel part is that the thing you spoke into your phone is running on your Mac before you finish pocketing it.

Push is free. Voice todos are unlimited, with 100 recording minutes included each calendar month. Routing, integrations, and on-device intelligence are included for everyone.

Pairing the phone to a Mac is a thirty-second QR-code scan. Sync uses the same relay the browser extension does.

The web

A button you click
while you’re already there.

The Push Chrome extension is the same idea as the iOS app, scoped to one place: whatever webpage is in front of you. Click the button, optionally type a note, optionally include a screenshot of the visible viewport, and an issue lands on your Mac with the URL, your note, and the screenshot attached.

Within thirty seconds the issue’s title goes from “Saved page” to whatever a Claude Haiku run on your Mac quickly summarizes the page as. If you saved this URL before, the second click adds a comment to the existing issue instead of a duplicate.

Pairing is automatic if you are on the same Wi-Fi as your Mac — the extension probes 127.0.0.1:3100 and finds it. Remote? Pair once, and it talks to your Mac through the relay using a permanent device token.

The promise is the same as the phone’s: capture lands on your machine. There is no SaaS to trust. The extension talks to the server you run.

One loop

One capture,
end to end.

What the system actually feels like, in the time it takes to walk a block.

  1. outside

    You are walking the dog. You think of a copy bug on the marketing site, the second screen down.

  2. phone

    You squeeze your AirPods. The Push Live Activity in the Dynamic Island says it is listening.

  3. phone

    You finish the thought. On-device models extract a title, a destination — Claude Code in push-website — and what to do.

  4. relay

    The structured task crosses the Cloudflare Worker and follows the open tunnel to your Mac.

  5. Mac

    Your Mac stores it as queued. The task waits for the next heartbeat.

  6. Mac

    Heartbeat. The claude_local adapter starts Claude Code in ~/push-website. The agent reads the task and begins.

  7. agent

    The agent needs confirmation before deleting a file. The Feed gets an approval card. APNs pings your phone.

  8. phone

    You glance at your phone and tap approve.

  9. Mac

    The Feed item closes. The agent continues. The next heartbeat will report completion.

That is one loop. Voice on a sidewalk. Heartbeat on the Mac. APNs back to the phone. The connective tissue is the boring, load-bearing part — atomic marker writes, hardware-fingerprinted tunnels, OAuth-gated subdomains, JSON frames over WebSockets.

None of which you should have to think about. You should just think the thought.

Why this shape

Vendor apps own one agent.
Push owns the connections.

Anthropic ships Claude.app. OpenAI ships Codex.app. Each one is opinionated, well-built, and faithful to its single agent.

The future they describe is one where you pick a vendor and live inside their app. That is a fine future for some users. It is not ours. We use four agents in a normal week, from a phone in the morning, a browser at lunch, and a terminal in the afternoon.

A vendor app cannot be neutral. It is not their job to make Codex easy when you are paying for Claude.

Push’s job is to be neutral — the substrate where capture, orchestration, and review hold the same shape no matter which agent is running underneath.

The terminal is where we live, day to day. Behind it: the phone you carry, the browser already open, the relay you never think about, and the heartbeat that turns I want into it’s running into here’s what it did.

The terminal is the front. The system is the bet.

Honest about polish

What ships,
what is behind a flag,
what we are still working on.

A real product has rough edges. We will keep showing them here as the lines move.

Production

  • Mac

    Terminal · Sessions · Feed · Issues · Files · Agents · Skills. Nine runtime adapters. Heartbeat. Embedded Postgres.

  • iPhone

    Voice capture · on-device Whisper · Foundation Models extraction · Live Activity · Home widget · 100-minute monthly recording guardrail. Six destinations live today.

  • Browser

    Chrome Web Store release. URL + screenshot + note capture · auto-enrich within 30 seconds · URL deduplication · local loopback · remote pairing.

  • Relay

    Cloudflare Worker · stable per-Mac subdomain · APNs delivery · Apple Sign-In gate · hardware-fingerprint lock · TLS in transit.

Behind a flag

  • Mac

    Memory sidebar (knowledge graph) · Costs sidebar (spend rollups) · Quick Terminal popup hotkey.

  • iPhone

    Control Center recording widget — code present, gate disabled.

Still working on

  • Mac

    Lab — the experimental web/native UI unification, dev builds only.

  • Relay

    End-to-end encryption at the relay layer is on the roadmap, not shipped.

  • iPhone

    Cursor is already a runtime adapter on the Mac, but not yet in the iOS routing UI.

Where we started

We lead with the terminal because that is where the work happens.

We built everything else because the work does not start there.

A captured voice memo, a routed agent run, an approval on the phone, and a fresh terminal tab in the morning all reach for the same thread.

Push is a small house. The terminal is the front door.
← Back to the terminal