Argus

Argus Notices
Research Done
Crash Noticed
Crash Fixed
Screen Answered in Chat
Allow Deny
Sanctum Themes
Sanctum Models
Sanctum Skills
Arc Reactor
Hades Theme
Argus Notices while you Code
Orb Looking at your Screen
Orb asks before resubmitting

Inspiration

Assistants wait to be asked. That is the whole problem. By the time you have written out what you want, you have already done the thinking that was the hard part.

We wanted the opposite: something that is already watching, already has the context, and speaks first, but only when it genuinely has something worth saying. The myth gave us the name. Argus Panoptes was the hundred-eyed giant who never slept, set to watch and never blink.

What it does

Argus runs on your machine and watches what you are actually doing, the files in your project, the output of your dev server, the page you are reading. Most of the time it stays quiet. That restraint is the feature; an assistant that interrupts constantly gets turned off.

When something concrete changes, a cheap model decides whether a competent colleague would say something. If yes, Argus speaks first:

"You pulled two papers into refs/ and opened an empty notes.md. Want me to extract the key points into notes.md?"

Say yes and it searches the live web, reads the PDFs off your disk, reasons over both, and writes a finished document back to your filesystem, then tells you the thing you did not want to hear:

"Your Dec 2025 notes are outdated: all four Nemotron 3 models are live on Token Factory today, not just Nano."

It does the same for code. When our dev server threw a real TypeError, Argus noticed in 1.15 seconds, named watchlist.js:24, and on one click read the file, wrote the fix, and the server restarted clean.

How we built it

Three Nemotron models, because the product forces it. This is not model roulette, each tier exists for a reason we can defend:

Stage Model Why this one Watcher Nemotron 3.5 Lightning Runs constantly. 1M context at $0.06/M input. A look costs $0.00007, so always-on is actually affordable. Oracle Nemotron 3 Ultra 550B The reasoning moment: plans the work, then writes the final document or code fix. Hands Nemotron 3 Nano 30B Fast, cheap, high-volume tool calling. We measured reasoning instead of guessing. All Nemotron 3 models reason by default. We probed all four on the watcher's real JSON task (scripts/probe_reasoning.py) and found Lightning breaks with thinking on, its reasoning spills into the answer, producing invalid JSON in 600 tokens and 2.8s. With chat_template_kwargs: {enable_thinking: false} it returns valid JSON in 25 tokens and 0.8s. So Argus switches reasoning per tier: on for the Oracle, off on the hot path.

Model IDs are resolved, not hardcoded. The live catalogue disagrees with the published docs on casing, Nebius's own cookbook says nvidia/nvidia-nemotron-3-nano-30b-a3b, the API serves nvidia/NVIDIA-Nemotron-3-Nano-30B-A3B. Argus queries /v1/models at startup, binds each tier case-insensitively, and falls back down a chain, so an unavailable Ultra degrades to Super instead of crashing.

Argus knows what it is running on. An early version confidently told us Nemotron 3 Ultra was unavailable, while Ultra was writing the sentence. Now the live Token Factory catalogue is injected as first-hand fact that outranks any web page, and it correctly flags stale user notes instead.

Two plug-in sockets, so it grows without surgery. Tools (core/tools/) and sensors (core/sensors/) are each one file per capability, auto-discovered by a registry against a frozen contract. We built the sensor socket on one side of the repo while the terminal and browser sensors were written on the other; they dropped in and /health picked up both with zero changes to core code.

It cannot run away with your money. Token Factory bills your card once the balance is gone and offers no server-side cap, so the cap lives in the router: every call is refused before it is sent once spend reaches ARGUS_BUDGET_USD. The ledger is persisted atomically, survives restarts, and a corrupt ledger fails closed.

Safety we actually implemented, not just intended. File tools are confined to the workspace (.., absolute paths, other drives and symlinks out are all refused, with tests). The headless browser is read-only behind a public-IP-only proxy that re-validates every request, so redirects cannot reach your LAN. The browser extension is off by default, ships a sensitive-domain denylist, and strips form fields from both the selection and the page text.

Challenges we ran into

1) Making it shut up. The first watcher offered to help constantly. The fix was mostly prompt work plus cooldowns, and one structural insight: after Argus finishes a task it re-baselines, so it never comments on its own writes. 2) The writer kept drifting. Asked to produce a document and call a tool, Ultra would sometimes skip the save, or "improve" its way into three extra files. We made writing deterministic: the model returns the document, the code saves it. One file, every time. 3) An agent that reads the web will confidently tell you things do not exist. Absence of evidence kept becoming evidence of absence. Fixed with an explicit rule and first-hand platform facts. 4) Enforcing limits in prompts does not work. "Use at most two searches" was ignored; the cap now lives in code, by removing the search tool after two uses.

Accomplishments that we're proud of

The watcher spoke correctly on 3 of 3 runs for the research scenario and stayed quiet on routine edits.

A real crash-to-fix cycle, end to end, in a real project: detection in 1.15s.

$0.26 of real spend built the entire project. A full task costs about $0.001–$0.05; a worst-case 8-hour day of watching is about $0.10.

12 test suites, including the unglamorous cases: a tool that raises, bad arguments, non-JSON model output, corrupt spend ledgers, and SSRF attempts.

What we learned

Most of the quality is in restraint and in deciding what not to hand the model. The three-tier split was forced by economics, and ended up being the cleanest part of the design. And verifying a model's behaviour beats trusting its documentation, the reasoning-toggle measurement changed the architecture.

What's next for Argus

Sandboxed cloud sessions so Argus can work while the laptop is shut; a memory of what you have already been told so it never repeats itself; and more sensors, the socket is the whole point.