Your agent already writes the code. Superagent gives it a place to work — and
gives you a place to watch. Every project is a chat sitting next to the thing
being built: a real browser on the sites you're already logged into, the files
it's editing, an iOS Simulator streamed straight into the window. Every chat
works in its own copy of the project, so nothing collides. And when you leave
the desk, the iPhone app follows the conversation and lets you answer the
agent's questions from anywhere.
Everything runs locally on your Mac, on the agent subscription you already have
— Claude Code, Codex or Antigravity, switchable per chat. No middleman server, no API key, no
AI of its own — and the whole app is open source, so you can read exactly how it
touches your browser.
For Antigravity, install the agy CLI and run agy in Terminal to sign in with
Google, then select Antigravity in the chat’s agent picker. Its model picker
reads the models available to your account.
What it does
Build it and watch it, side by side. The chat sits next to a real browser.
Ask for a change and watch the page update in the same window — no alt-tabbing
to find out whether it worked. Point it at a local dev server or any live site;
the agent can start the server itself and iterate while you watch.
Eight chats, one window. New in the 2.1 beta. Drag a chat from the
sidebar onto the window and it opens beside the one you are in — up to eight,
from any projects, and chats that belong to no project too. Drag a result out of
⌘K the same way, or press ⌘↩ on it
to open it beside. Move a window by its handle and pull its edge to resize it.
Each split is kept as a row under Splits in the sidebar: a small picture of its
windows with each project's logo, its chats, and a dot while one of them works.
Click it to go back; × takes it apart. ⌘1–8
picks a window, ⌘⇧[ and
⌘⇧] go round them. A narrow window keeps its
browser or simulator as a small view inside it. The iPad app splits the same
way, with up to four windows.
An agent that can use the browser. Your agent drives that same browser: open a
page, click, type, read it back. Not a hidden browser it describes to you
second-hand — the one on your screen, with your logged-in session. You watch it
work and can take over any time. Automation only ever happens in Superagent's
own pane, never in your personal browser.
An iPhone in the window. A real iOS Simulator, streamed into the app at
about a frame a second, that the agent can tap, swipe and type into. Ask it to
build and run, and it does — then looks at the screen and fixes what it sees.
Your Mac's agent, in your pocket. Pair once from Settings → Phone and the
iPhone app follows your Mac from anywhere: the conversation as it happens, a
prompt from the sofa, a yes or no when the agent asks. End-to-end encrypted,
through a relay that stores nothing and can read nothing. On iPad it takes the
Mac's shape — sidebar left, conversation right, the page beside it.
Ask from anywhere. Superagent also sits as a small tile in the corner of
your screen, over every app. Click it or press its shortcut, say where (the
Computer, or any project) and what, and the answer comes back beside it without
opening the window. It spins while it works, turns amber when it needs your
yes, and every request is an ordinary chat you can open afterwards.
Run the app by asking. From the tile or any chat, typed or spoken: "go to
the wepush chat about e2e testing", "what's running?", "start a chat in the
portal to fix the header", "show me its board", "go back". It finds the
conversation from how you describe it and takes you there.
It can use your Mac, when you let it. Turned on in Settings, an agent can
see the screen, read an app's controls by name, and press, fill and click in
any app. It asks first, for the Mac and again for each app, and before
anything named Quit, Delete or Send. Password managers, password prompts and
the lock screen are out of bounds, you can add any app to that list, and ⌥Esc
stops it from wherever you are.
Everything in its place. The Computer sits at the top of the sidebar with
its own conversations under it. Then one Projects section: your open browser
tabs first, then your projects, each with its own icon and its conversations
nested underneath — a spinner while the agent works, a dot when it needs you,
and the git branch where you would expect it. The globe on its header opens a
new tab; the folder adds a project. Pinned chats go in whatever order you drag
them into.
Getting the phone app
TestFlight, or build it from
source — see its README.
- Ask mode. A permission mode where the agent checks with you before it
acts — on the Mac, or on your phone if that is where you are.
- More than one Mac. Switch between paired Macs from the title at the top
of the phone app; it reopens on the one you picked last.
- Private by construction. Everything between the phone and the Mac is
end-to-end encrypted with a per-device key from the pairing QR. Both sides
dial out to a tiny blind relay
(superagent-relay) that forwards
ciphertext and stores nothing, so it works behind any network with no setup.
Run your own with one command and change the URL in Settings → Phone.
- Connects only when it is used. The Mac opens its relay connection when a
phone is paired or being paired. An install that never pairs a phone never
connects anywhere.
Also in the box
- Every chat is its own checkout. A new conversation gets a private copy of
the project on its own branch, cut on its first message and named after what
you asked for. Keep folds its work back in as one change; Throw away
deletes it. The project row keeps a conversation that works in the folder
itself, for when that is what you want.
- A board the agent keeps. Backlog, next, doing, done — per project, and
Claude moves the cards as it works. Watch them move while you talk to it.
- A plan you can steer. When the agent writes itself a to-do list, it shows
up pinned above the conversation — tap a pending step to send it straight
back as the next thing to work on.
- Routines. "Check this site every hour," in plain language, on a timer.
/loop, self-paced. Ask it to keep going — reviewing, testing, refining
— and it decides its own pace between rounds instead of you re-prompting it
every few minutes.- Dashboard. Turns per day, tasks done, a streak — and which projects
actually got your time. Computed locally.
- Every project shows what it is. A website's favicon, a native app's own
icon from its Xcode AppIcon, or a glyph for a screenplay, design or music
folder — pulled straight off the project's own files, even inside a folder
that holds several repos. It shows in the sidebar and next to projects and
conversations in ⌘K. Pick your own any time.
- Several repos, one row. A project folder that holds several repos folds
them away under a caret on its own row, and remembers whether you left it
open. A repo that is still cloning says "cloning…".
- Files & PDFs. Click any file to read it — PDFs, images, markdown, source —
right beside the tree; annotate PDFs in place; drag files into the chat.
- A screenshot lands in the chat, not just a link to it. When a tool call
produces a picture — a simulator screenshot, a page it read — it shows up
inline, right under the step that made it. Images the agent puts in its reply
show as small previews; click one for full size.
- Snip to attach. ✂ on the browser or the simulator (or ⌘⇧S): drag a box
right on the page or the phone screen and the crop lands in your message, at
full resolution.
- Multiple browser tabs per chat. Open more than one page without leaving
the conversation — switch between them the way you would in a real browser.
The agent keeps its own tab, so one you opened to look something up isn't
taken over by its next navigation.
- A real phone size. The agent can switch the browser pane to a real
390×844 mobile viewport, to desktop, or to both side by side, so it checks a
mobile layout at that size instead of faking one.
New in the 2.0 beta
Turn on Beta updates in Settings → About to get these. They reach everyone
when they are ready, and may change before then.
- The dot: the best agent is the one that disappears. Turn it on in
Settings → General (or while setting up), close the window, and Superagent
goes on working; what is left is a small tile in the corner of your screen,
over every app. Press
⌥ Space (or ⌃⌥ V to say it out loud)
and ask: a question, a job, or the app itself. "Go to the wepush chat about
e2e testing." "What's running?" "Start a chat in the portal to fix the
header." It finds a conversation from how you describe it and brings the
window back on it. Its project list is a switcher too: find a project, ⌘↩,
and you are there; "switch to the portal", said to the dot, switches the dot
itself and leaves the window alone. It tells you when a job is done, window
or no window. And it gets out of the way: hidden while Superagent's own
window is in front, and faded to an ember when nothing is going on, until
the pointer finds it.
⌃⌥ S brings Superagent forward from anywhere.
- Computer use, off until you turn it on. An agent can see the screen, read
an app's controls by name, and press, fill, click and type in other apps,
for the things that have no command line.
- It asks first: for the Mac, again for each app, and every time before
anything named Quit, Delete, Send or Pay, before reading your clipboard,
and before pasting what you copied. "Ask before each step" puts every
click and keystroke to you in words.
- It stays out of password managers, Keychain, password prompts, the lock
screen, Superagent itself, and any app you list. An app can be "look
only". "Show it only the apps you allowed" covers everything else in its
screenshots.
⌥ Esc stops it from any app. A ring shows where it is about to click,
and there is a record of what it did.- Those questions are answered at the Mac: a paired phone can say no, never
yes.
- It is a beta of something powerful. The safeguards are layers, not a
proof: an agent also has a shell of its own, and the guard on that is a
list of known ways round. Start with "Ask before each step" on.
- Replies that arrive. A reply comes in a word at a time, each word out of
a blur into focus, at an even pace however unevenly the agent sends it, and
never half a word. In the chat, in the dot, and on the phone.
- Quieter loops. A round of
/loop shows as a small note marked Loop,
with what you asked and none of the instructions the agent gets with it.
- A name you gave a chat stays. Neither the first message nor the agent's
own summary renames a conversation you named.
- A tour of how it works when you set up, and again any time from
Settings → About.
- Setting up asks how it should behave. Four decisions, once: what happens
when an account runs out (ask, or switch on its own), whether agents keep
working with the lid closed, the dot, and computer use. Left untouched,
nothing changes; all of it is in Settings afterwards.
The small things
- Everything survives a restart — panes, open files, active chat — even
through updates.
- Never steals your focus. Agents finish quietly in the background; the
window comes forward only when you ask.
- Light on memory. Sessions start on your first message and wind down when
idle; preview panes are released when a chat is in the background.
- Interject mid-turn. Type while the agent works and it sees your message
before it finishes — like the terminal.
- Notifications that say something — done or has a question, with a
summary of the agent's actual last reply.
- Many chats per project. They name themselves after what the conversation
turned out to be about. Starting a new one never loses the old.
- Talk instead of typing. Hold ⌥Space, speak, let go.
Your voice is transcribed on your own Mac and never leaves it.
- Quiet by default. A burst of activity folds into one line you can open,
instead of a wall of noise. Consecutive messages sent moments apart cluster
together, iMessage-style, instead of every bubble standing on its own.
- See every edit the moment it happens, with just the change highlighted.
- Model and mode pickers that match Claude Code's own. The model list is
read from the Claude Code you have installed, so a new model shows up without
an app update, and "Default" says which model it actually is. The agent
picker shows the real Claude and Codex logos.
- Stop actually stops. Interrupting a turn kills the whole job it started
— a build, a dev server — not just the agent process sitting above it.
- Quit means quit. Quitting Superagent stops everything it started: chat
agents, their background tasks, and routine runs.
- Light when idle. The pulsing status dots no longer redraw the window
every frame, so an idle window uses much less CPU.
- Logs you can clear. They are the app's own notes for finding a fault,
nothing of yours; Settings → Advanced → Storage clears them, and a memory
snapshot from a crash is removed after a week.
- See what's using the space. Settings breaks storage down by project, so
clearing an old conversation's history is a click, not a guess.
- Updates itself. Signed, notarized, delivered in the background — restart
when it suits you, with a "What's new" for each release. Restart when
finished waits for the chats still working, and sits as a small chip until
then.
- Light and dark, following your system.
What it needs — and what it talks to
- A Mac with Apple Silicon.
- Claude Code, installed and signed in. Your
subscription is the only thing Superagent runs on — nothing extra to buy, no
key to paste.
- Xcode, only if you want the simulator.
- An iPhone with the companion app, only if you want your phone in the loop.
Network, in full: Claude Code's own connection to Anthropic; a check of this
repo's releases for updates; the Whisper model for push-to-talk dictation,
downloaded from Hugging Face the first time you hold the key and cached after
that (the transcription itself never leaves the Mac); and — only once you pair
a phone — one outbound connection to the companion relay (the project's by
default; swap in your own in Settings → Phone). Nothing else leaves the
machine.
The three repositories
All of them in one place: github.com/pungme?q=superagent.
Run it from source
cd app
npm install
npm run dev
npm test runs the unit tests, npm run test:e2e builds the app and drives it
with Playwright. Contributions welcome — see CONTRIBUTING.md.
Roadmap
- Other agents. Superagent wraps Claude Code today, but in the end it's an
LLM driving a home — the plan is an agent layer that other CLIs and local
models can plug into.
- A desktop. A workspace that behaves like a real computer: several things
open at once — browser, files, a terminal, a simulator — arranged the way you
left them, with the agent working across all of them.
- Memory that writes itself. Your agent relearns the same things in every
new session — your conventions, a project's traps, which command actually
deploys. Superagent should notice those and carry them across projects, in a
list you can read, edit and delete.
- Watchers. Routines already run on a schedule and the browser already
reads pages. Point one at a page and get told what changed, with a before
and after.
License
MIT
