Skip to content

Repository files navigation

Argus multi-eye agent mascot

Argus

Persistent, reviewed autonomy for research and engineering

Long-running agent work that can plan, execute, verify, pause, and continue beyond a single model turn.

Preview v0.1.1 · Official open-source release on the way.

GitHub Stars License Python arXiv

Website · Video Demo · Technical Report · arXiv:2608.05144 · WeChat Community · English / 简体中文

ManagerPlannerEngineerReviewer


What is Argus?

Most agents are optimized for one conversation or one coding turn. Argus is built for work that lasts: it keeps state, separates execution from judgment, and resumes from verified progress instead of starting over.

Capability What it means
Persistent state Tasks, checkpoints, decisions, Skills, and evidence survive sessions and runtime upgrades.
Independent review Execution and verification stay separate; normal rounds end with a Reviewer judgment.
Four-role runtime Manager, Planner, Engineer, and Reviewer have distinct authority and responsibilities.
Real tool use Agents work through files, terminals, experiments, APIs, and inspectable artifacts.
Domain extensibility Verticals can define custom stages, tools, evidence requirements, and completion standards.
Multiple backends Run with GitHub Copilot CLI, Pi, Codex CLI, Claude Code, or OpenCode.

Runtime model

Authority Responsibility
01 Manager · Control Interprets operator intent, selects the workflow, and owns stage transitions.
02 Planner · Direction Chooses the next high-value task and defines the evidence it must produce.
03 Engineer · Execution Implements, researches, runs experiments, and creates inspectable artifacts.
04 Reviewer · Verification Independently checks correctness, evidence, limitations, and completion.

A project can stop, resume, survive a runtime replacement, and continue from its latest verified position.

Native backends: GitHub Copilot CLI · Pi · OpenAI Codex CLI · Claude Code · OpenCode

Quick Install

Requirements

  • Python 3.11+
  • Node.js 22+
  • One supported Agent CLI installed and authenticated through its official login flow

🚀 Agent-assisted installation (recommended)

Tip

Skip the manual installation steps. Send the complete prompt below to Codex CLI, Claude Code, GitHub Copilot CLI, Pi, or OpenCode. The agent will inspect the environment, install Argus, connect the current backend, and verify it with argus --doctor.

Read https://github.com/lbx154/Argus/blob/main/docs/agent-install.md and follow
it to install and configure Argus on my machine. Prefer the Agent CLI currently
running this conversation as the Argus backend. Perform the environment checks,
installation, configuration, and argus --doctor verification. Before account
login, sudo, global configuration changes, or any other action requiring human
authorization, explain why and wait for my approval. Never ask me to paste a
password, access token, or API key into the conversation.

The agent will follow the installation execution contract.

Install

git clone https://github.com/lbx154/Argus.git
cd Argus

python3 -m venv .venv
. .venv/bin/activate
python -m pip install --upgrade pip
pip install -e .

Connect a backend

argus --setup --non-interactive \
  --backend copilot \
  --accept-house-rules

Use copilot, pi, codex, claude, or opencode for --backend.

Launch

argus
argus --doctor   # verify the installation
argus --status   # inspect the current runtime

Interfaces

Terminal cockpit

argus

Use the terminal cockpit to talk to the Manager, follow live work, inspect state, and resume projects.

Web UI

Start Argus and open the Web UI in your default browser:

argus --web

Default address: http://127.0.0.1:8799

The Web UI follows the browser language on first launch and supports English and Simplified Chinese. Use the language button in the session sidebar to switch; the selection is saved in the browser.

argus --web --no-open    # start without opening a browser
argus --web --port 8800  # use another port

Remote server over SSH

On the server:

argus --web --no-open

On your computer:

ssh -L 8799:127.0.0.1:8799 user@server

Then open http://127.0.0.1:8799 locally.

Direct LAN access

A non-loopback bind is always protected by a bearer token. If ARGUS_SKILL_WEB_TOKEN is set it is used; otherwise one is minted for that run:

argus --web --host 0.0.0.0 --port 8799 --no-open

This prints the address other devices can reach, the token, and a QR code. Set the token yourself to keep one across restarts:

export ARGUS_SKILL_WEB_TOKEN="$(python -c 'import secrets; print(secrets.token_urlsafe(32))')"

To serve without a token — only behind your own authenticating proxy — set ARGUS_SKILL_WEB_ALLOW_INSECURE=1.

From a phone

Telegram, Feishu/Lark, and the web UI all work from a phone. The two chat bots dial out, so a daemon behind NAT needs no tunnel and no public URL:

# Feishu / Lark — WebSocket long connection, no request URL to configure
pip install 'argus-skill[feishu]'
export ARGUS_SKILL_ENABLE_FEISHU=1
export ARGUS_SKILL_FEISHU_APP_ID=cli_xxx ARGUS_SKILL_FEISHU_APP_SECRET=xxx

# Telegram
export ARGUS_SKILL_ENABLE_TELEGRAM=1
export ARGUS_SKILL_TELEGRAM_BOT_TOKEN=... ARGUS_SKILL_TELEGRAM_CHAT_ID=...

Both bots serve the same commands (/add, /status, /nudge, /backlog, …). The web UI is installable to the home screen and pairs by scanning the QR code printed by argus --web --host 0.0.0.0.

See docs/mobile.md for the full setup.

Advanced usage

Argus is designed to be changed, not merely configured.

Adapt the runtime

If you are an agent enthusiast, deploy Argus locally and make the complete loop fit the way you work. Tune role prompts, workflow boundaries, review policy, tools, and operating conventions; connect your own infrastructure; preserve the behavior you care about with tests.

Build your own Vertical

A Vertical gives your field its own stages, Skills, datasets, tools, evidence expectations, evaluation methods, and completion criteria. Planning and review can then follow the real standards of your domain instead of a generic process.

Use another agent as the outer layer

GitHub Copilot, Pi, Codex, Claude Code, OpenCode, OpenClaw, or Hermes can be the environment from which you invoke Argus, inspect its state, operate its local CLI or Web/API surface, and continue improving the deployment.

  • Native Argus backends: GitHub Copilot CLI, Pi, Codex CLI, Claude Code, OpenCode
  • External agent operators: OpenClaw, Hermes, or any agent that can use a shell or HTTP API

Useful entry points:

argus --doctor
argus --status
argus --web --no-open

The most capable setup is often an Argus instance deliberately adapted to your own ambitious field and way of working.

Update

cd Argus
git pull --ff-only
.venv/bin/python -m pip install -e .
.venv/bin/argus

Argus detects stale local WebAPI and daemon processes and replaces them at a controlled task boundary.

WeChat community

Scan the QR code below to join the Argus community. The expiry date is printed in the image; if it has expired, open an Issue and ask the maintainers for the latest code.

Argus WeChat community QR code

About

No description, website, or topics provided.

Resources

Stars

85 stars

Watchers

3 watching

Forks

Releases

Packages

Contributors

Languages