Argus
The workspace around your existing AI agents.
Any CLI. Any tmux session. Terminal, files, reports and hand-offs together on desktop or phone. Argus does not replace tmux, wrap the agent or send your work to a hosted control plane: if it runs in a terminal, it works.
curl -fsSLO https://raw.githubusercontent.com/andreaderuvo/argus/master/install.sh
less install.sh && bash install.sh
argus --allow-write # prints a URL with a token in it
MIT · Python + vanilla JS · no build step · no database · self-hosted
1
2
3
4
- 1An agent, mid-run, asking you something. It rang while you were in another tab.
- 2The other one prints where it wrote. Those paths are links.
- 3The folder it is filling, updating on its own.
- 4The report, rendered beside the session that made it.
The half-hour you spend checking on it
Without
- ssh in,
tmux attach, squint at a pane. - Scroll back to find the path it printed.
scpthe report out, orcatit and read markdown as markdown.- It asked you a question forty minutes ago and you did not know.
- From the phone: nothing. You wait until you are back.
With Argus
- The session is a tab, still running, exactly as you left it.
- The path it printed is a link — one click, open beside it.
- Markdown, PDF, images and logs render in place, next to the terminal.
- It rings — finished and waiting for you look different.
- From the phone: the same desk, the same sessions, and a keyboard bar that works.
Six seconds each
Recorded from a demo instance: fabricated sessions, fabricated files, real interface.
Click what it printed
Hand the work to the other agent
Keep the arrangement
The same session, on the phone
Two agents on one job, without a protocol
Two agents on one machine share a filesystem, so what has to travel
between them is not the work — it is a short sentence and a pointer to where the work
is. Argus ships the patterns ready-made: together, where a plan file
says who owns which file and neither may touch the other's, and
one builds, the other reviews, where the reviewer never edits and
finishes on VERDICT: OK or VERDICT: REDO.
That last line is readable by a machine as well as by a person, so Argus can read it and hand a REDO back on its own — off unless you turn it on, and counting down, because two agents bouncing a change between them for six hours unattended is not a feature. It works with any agent that can be told to end on a sentence, which is all of them.
The point is what sits next to the terminal
An agent's output is mostly references to things: a path it wrote, a report it generated, a number in a file. So the terminal and the filesystem are the same room.
Paths are clickable
A path printed in the session opens beside the terminal, and the file browser jumps to it and marks it. Relative paths resolve against the pane's own working directory.
Everything it printed, in one tray
Every absolute path and URL that goes past in a desk's terminals collects in a list you click, checked against the filesystem first. Drag a line onto a terminal and it is typed there: that is how you tell an agent which file to look at.
Read it in place
Markdown with its figures and its mermaid diagrams drawn, PDF with a search box, Word through pandoc, images, and a log that starts at the end.
It tells you when it is done
An agent hook says whether it finished or is waiting for you, and the two look different on screen — in another tab too, on the title and the icon, no certificate needed. Guessing from the output is what makes notifications noise.
Windows, not tabs
Terminals, folders and documents side by side, snapping to each other. Shared edges behave as splitters, and each desk has its own link and its own starting folder.
Several agents, and something to conduct them
A small framework — one standard-library file — owns the part that is always the same: the “write this file, then ring” contract appended to every prompt, one correct waiting loop, the session names, a git worktree per agent. On top of it, three worked orchestrators of about twenty lines each, all run against real tmux before they were committed: N attempts at one problem and a judge, N referees with different lenses and an editor, a backend, a frontend and a tester handing work to each other in order. It stays ordinary Python, so a loop is a loop.
Start the work, not just watch it
The same button that made an empty session now asks what to run — a shell, or an agent from a list you write — in which folder, and what to say to it first. It waits for the thing to stop drawing before typing, and does not press Enter unless you say so. If the folder is a git repository it will make a worktree on a new branch and start the agent in there, so two of them are not editing one checkout. On a phone this is the difference between answering an agent and beginning one.
Prompts you keep, not retype
Folders of prompts written with placeholders, and named sets that fill them — one wording serves every project. Hover to see exactly what it will say before it says it, drag one onto a terminal to hand it over, or aim it at two agents at once and press it once. Star the four you send all afternoon and they sit at the top of every desk, without their folders.
Everything else it does
Files appear on their own
A folder you are watching notices what a job writes into it, without you refreshing anything.
Paste a screenshot
Ctrl+V in a listing writes it into that folder, numbered, and hands back its path — ready to paste into the session as the next instruction.
Type into two sessions at once
Chain the terminals and what you type reaches all of them, Enter included. The chained windows are outlined and counted, so a broadcast is never something you have forgotten about.
Keys, if you want them
? lists every shortcut — Ctrl+Alt for the screens,
Ctrl+Shift for the desk you are on — and any can be rebound by
pressing the combination you want. They stay out of a terminal's way: what you
type into a session belongs to the session.
Dress it, safely
Ready-made looks for tmux, from a button on the terminal: one session or all of them. Colours only, from a fixed list, checked on a throwaway server first — a theme that could take a session down would not be worth having.
The machine itself
CPU, memory, swap, GPUs, disks and listening ports, with a plain reading of whether anything is about to go wrong.
Reach a port it cannot see
Type a number to stand in front of a port nothing found yet. Or paste the login
callback that died on localhost because you did the logging in on a
different machine: it is forwarded to the port it was meant for.
A board over several machines
Panoptes is one page over every Argus you run: which machines are up, what is running on each, and a way in — one tile per machine.
On a phone, properly
Not a desktop page squeezed into a phone: a key bar for the modifiers a phone has not got, drag-to-scroll that keeps up with your thumb, a long press to open a path, windows you can resize with a finger, and a full-screen button because F11 is not on a phone.
And a box to write a line in — because typing into a terminal on Android can duplicate words, which is a browser bug no app can fix from the outside. In an ordinary text field the keyboard behaves, and the finished line goes to the session in one go.
More of it
Windows you arrange yourself, kept between visits.
Documents rendered, not downloaded.
Is the disk about to fill up again?
Files as a list or a tree, sizes on request.
Run it in a minute
curl -fsSLO https://raw.githubusercontent.com/andreaderuvo/argus/master/install.sh less install.sh && bash install.sh argus --allow-write # prints a URL with a token in it
Into ~/.local/share/argus, with a launcher in ~/.local/bin. No
sudo, no system package, nothing outside your home — so it does not ask,
because there is nothing to ask. The same line again updates it in place and leaves your
token alone; -s -- --service also writes a systemd user unit;
-s -- uninstall removes it and keeps your configuration.
Or a container, which is the answer on Windows — through WSL, because tmux is a Unix program and has no native Windows build:
git clone https://github.com/andreaderuvo/argus && cd argus ARGUS_UID=$(id -u) ARGUS_GID=$(id -g) docker compose up -d
Versioned amd64/arm64 images are also published at
ghcr.io/andreaderuvo/argus;
the Compose file documents the one-line switch from a local build.
Or the old way, git clone and pip install -r requirements.txt.
All three are checked on every change, on Linux and macOS: installed into an empty home,
started, a real tmux session listed through the API, updated, removed — and the image is
started against a real tmux to prove it can see the host's sessions.
Open the URL it prints, or scan the QR code it can print, and the phone is in. No build step, no database, no agent to install anywhere — and nothing changes about how you use tmux: Argus attaches to the sessions you already have and leaves them running when you close the tab.
tailscale serve --bg 8090. That also gives it a real certificate, which
is what makes the app installable and the clipboard work. An SSH tunnel or a reverse
proxy work too — the
network guide
has the configuration for each.
Before you try it
Does it change anything about my tmux?
No. Argus attaches as a client to the sessions you already have, so what you see in the browser is the same pane you would see over ssh — and closing the tab leaves everything running, because a client is not a parent. Your config, your keys, your windows.
Does the agent need a plugin?
No. Argus reads what the session prints and types into it, which is all any agent does anyway. The one optional part is a hook that says finished or waiting for you — one line in your agent's config, and without it you get everything except the bell.
Is it just a web terminal?
The terminal is the part that already existed — ttyd and gotty do that well. What this is for is the other half of the job: the files the session is writing, the report it produced, the paths it printed, the prompt you hand to the second agent, and knowing from another room that it is waiting for you.
Can I put it on the internet?
You can, and you should think about it first. It is shell access behind a token, so the sensible shapes are a LAN, a VPN, or Tailscale — the last of which also gives you a certificate for free. Each device can hold its own token, revocable on its own, and the Journal records what changed and what was refused, with the address it came from, so has somebody been in here has an answer.
Several machines?
That is Panoptes: one page over every Argus you run, a tile per machine, which are up and what is running on each. Same idea, one level out.
What is it written in?
Python on the server, vanilla JavaScript in the browser. No build step, no bundler, no database — a file for the config and one for the journal. Clone it and run it; the whole front end is a folder of static files you can read.