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 page is a longer read. It’s for the kind of user who, after reading the front, wants to know what’s actually in the box. Everything below is shipping. Where it isn’t polished, we say so.
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.
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.
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.”
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.
The Feed is where agents ask you for what they need.
Approvals before destructive actions. Drafts to review. Choices that need a human. It isn’t an inbox in the email sense — it’s the I-need-you surface. You glance at it; you don’t drown in it.
What you saw on the front. Lives in both modes.
Every agent run, queued, running, completed, failed. The audit log of what happened.
The room where agents ask you for things — approvals before destructive actions, drafts to review, choices that need a human.
Work tracking. A board, a list, a kanban. Issues come from your captures, your terminal, or the agents themselves.
Whatever your agents produce, plus anything you ⌘-click from a terminal pane. Adaptive grid, agent filters, search.
The configurations themselves. Each agent is a runtime + a workspace + a prompt + a cadence.
The actions agents can call — Push-shipped, user-defined, and ones the agents themselves taught the system.
Two more — Memory and Costs — sit behind experimental flags. Memory lets you curate the knowledge graph your agents reference. Costs sums what they’re spending. Both work; neither is final.
Why local?
Your code is on this machine. Your secrets are on this machine. Your transcripts and your session histories should stay on this machine too. The Mac is the home because the home is where the data lives.
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.
TLS in transit, end to end. The Worker can read frames it forwards — that’s the cost of running a generic tunnel. Full end-to-end encryption is on the roadmap; today, your trust is in the same place it sits with any web service: the boundary, not the wire.
The relay matters because without it, your phone and your Mac can’t reliably find each other across networks. With it, they can — without ever going through anyone’s SaaS.
A voice memo from anywhere.
A task in the right place
by the time 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.
- 01Records
Audio to disk. A Live Activity in the Dynamic Island shows the elapsed time and a finishing-up state when you’re done.
- 02Transcribes
On iOS 26 with Apple Intelligence, whisper.cpp runs on the Neural Engine — fully on-device. On older devices or with intelligence off, it falls back to cloud transcription.
- 03Extracts
Apple Foundation Models pull structure out of the transcript: title, summary, due date if one’s implied, and the right destination. On-device when they can be.
- 04Routes
The structured task goes through the relay to your Mac. Within a heartbeat, the right adapter picks it up and runs.
There’s a hands-free mode for thinking out loud. AirPods triggering for talking-while-walking. A Live Activity for the lock screen. A widget for today’s count. None of that is novel. The novel part is that the thing you spoke into your phone is running on your Mac before you’ve finished pocketing the phone.
Free tier covers a hundred voice memos a month — enough for a heavy day, light week. Pro is $4.99/mo for unlimited. Routing, integrations, and on-device intelligence: free for everyone.
Pairing the phone to a Mac is a thirty-second QR-code scan. Sync uses the same relay the browser extension does.
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’ve saved this URL before, the second click adds a comment to the existing issue instead of a duplicate.
Pairing is automatic if you’re on the same Wi-Fi as your Mac — the extension probes 127.0.0.1:3100 and finds it. Remote? You paste a one-time QR code from the Mac into the extension, and from then on it talks to your Mac through the relay using a permanent device token.
No selected-text capture. No voice. No AI in the extension itself — the model lives on the Mac, the extension is pure capture. Chrome only, Manifest V3. Free, in the Chrome Web Store.
The promise is the same as the phone’s: capture lands on your machine. There’s no SaaS to trust. The extension talks to the server you run.
One capture,
end to end.
What the system actually feels like, in the time it takes to walk a block.
- 7:42:00outside
You’re walking the dog. You think of a thing — a copy bug on the marketing site, the second screen down.
- 7:42:08phone
You squeeze your AirPods. The Push Live Activity in the Dynamic Island says it’s listening.
- 7:42:24phone
You finish the thought. On-device Whisper transcribes; on-device Foundation Models pull out a title (“Fix the marketing-site copy bug”), a destination (Claude Code in push-website), and what to do.
- 7:42:25relay
The structured task hits the Cloudflare Worker. The Worker forwards it down the tunnel that’s been open between your Mac and the relay since you signed in last week.
- 7:42:25Mac
Your Mac’s server stores it. Postgres row, status: queued. The task waits for the next heartbeat.
- 7:42:55Mac
Heartbeat. The server scans for queued runs and finds yours. The claude_local adapter spawns a Claude Code session in ~/push-website. The agent reads the task and starts working.
- 8:01:12agent
The agent has a draft. It needs you to confirm a path before deleting a file. The Feed gets an approval card. APNs pings your phone.
- 8:01:14phone
You’ve put the dog away. You glance at your phone. Tap approve.
- 8:01:14Mac
The Feed item closes. The agent continues. The next heartbeat will report completion.
That’s 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.
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’s a fine future for some users. It isn’t ours. We use four agents in a normal week — Claude Code on most things, Codex when we’re stress-testing a model, OpenCode when we want to self-host, Hermes when we want speed. We talk to them from a phone in the morning, a browser at lunch, and a terminal in the afternoon.
A vendor app can’t be neutral. It isn’t their job to make Codex easy when you’re paying for Claude.
Push’s job is to be neutral — to be 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 you’ve already got open, the relay you’ve never had to think about, the heartbeat that quietly turns I want into it’s running into here’s what it did.
The terminal is the front. The system is the bet.
What ships,
what’s behind a flag,
what we’re still working on.
A real product has rough edges. We’re going to keep showing them on this page as the lines move.
- Mac
Terminal · Sessions · Feed · Issues · Files · Agents · Skills. 9 runtime adapters. Heartbeat. Embedded Postgres.
- iPhone
Voice capture · on-device Whisper (iOS 26) · Foundation-Models extraction · Live Activity · Home widget · paywall · iCloud backup opt-in. Six destinations live today.
- Browser
v0.2.0 in the Chrome Web Store. URL + screenshot + note capture · auto-enrich within 30s · dedup by URL · auto-loopback locally · QR-pair for remote.
- Relay
push-relay on Cloudflare Workers · per-Mac stable subdomain · APNs delivery · Apple Sign-In gated · hardware-fingerprint locked · TLS in transit.
- Mac
Memory sidebar (knowledge graph) · Costs sidebar (spend rollups) · Quick Terminal popup hotkey.
- iPhone
Control Center recording widget — code present, gate disabled.
- 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 as a routing destination — already a runtime adapter on the Mac, not yet in the iOS routing UI.
We lead with the terminal because that’s where the work happens.
We built everything else because the work doesn’t start there.
If you’ve read this far, you’ve seen most of what’s in the box. The part that isn’t on this page is the bit you’ll feel when you’ve used it for a week — the way 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.