Skip to content
Back to search

argus

MarketplaceWorks with Claude CodeGitHub

Argus persistent, independently reviewed research and engineering workflows

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/microsoft/ArgusAgent with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/microsoft/ArgusAgent'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/microsoft--argusagent/badge.svg)](/listings/microsoft--argusagent)

HTML

<a href="/listings/microsoft--argusagent"><img src="/api/listings/microsoft--argusagent/badge.svg" alt="findsafeskills safety rating" /></a>

Install

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

These steps run a script from the network that findsafeskills does not scan.

Choose the section for your operating system. Do not mix commands between platforms. All platforms need Node.js **22.12+** from [nodejs.org](https://nodejs.org/en/download) and one authenticated Agent CLI. Reuse the CLI you already work in; Argus does not require a separate account. Docker is not required for a normal Argus installation; it is only an optional prerequisite for the separate Harbor evaluation integration.

> [!TIP] > **Recommended: let the Code Agent you already use install and verify Argus.** > Copy the prompt in the Agent-assisted section below. The manual commands remain > available for users who prefer to install each step themselves.

| Agent CLI | Backend | Install | Authenticate | |---|---|---|---| | GitHub Copilot CLI | `copilot` | `npm install -g @github/copilot` | `copilot login` | | OpenAI Codex CLI | `codex` | `npm install -g @openai/codex@latest` | `codex login` | | Claude Code | `claude` | `npm install -g @anthropic-ai/claude-code` | Run `claude`, then `/login` | | Cursor CLI | `cursor` | `curl https://cursor.com/install -fsS \| bash` ([Windows](https://cursor.com/install?win32=true)) | `agent login` or `CURSOR_API_KEY` | | Pi | `pi` | `npm install -g --ignore-scripts @earendil-works/pi-coding-agent` | Run `pi`, then `/login` | | OpenCode | `opencode` | [Official install](https://opencode.ai/docs/) | `opencode auth login` | | Grok Build | `grok` | [Official install](https://x.ai/cli) | `grok login` | | Qoder CLI | `qoder` | `npm install -g @qoder-ai/qodercli` | `qodercli login` | | DeepSeek Harness | `dsh` | `npm install -g @deepseek-ai/dsh` | Configure `DEEPSEEK_API_KEY` or the dsh Models page |

**Separate Copilot account for Argus:** run `argus --setup --backend copilot --copilot-home "$HOME/.copilot-argus" --copilot-login`. After setup succeeds and existing Argus processes are restarted, ordinary Argus launches use that account without changing the caller's login. See [account binding, precedence and reset](docs/agent-install.md#dedicated-copilot-account).

**Research traces:** Copilot sessions are preserved by default. Opt-in session reclamation and raw I/O rotation now archive verified copies before reclaiming online files; archives do not expire automatically. Review the effective policy in Settings and monitor disk space. See [trace retention and export](docs/trace-retention.md).

<a id="argus-pi-preview"></a> <details> <summary><strong>Try Argus-Pi: install, connect and roll back</strong></summary>

This optional trial assumes Argus is already installed. You also need Git, Node.js **22.19+** and npm. Argus-Pi is currently a **source preview**, not a separately published npm package or desktop installer. Installing the upstream Pi npm package does not install Argus-Pi.

**1. Build a separate checkout in a new terminal.** Run each command only after the previous one succeeds; do not overwrite your existing global Pi installation.

git clone --branch main https://github.com/Argus-AiTeam/Argus-Pi.git
cd Argus-Pi
npm ci --ignore-scripts
npm run hydrate:model-data
npm run build:offline
npm rebuild --workspace=@earendil-works/pi-coding-agent --ignore-scripts
node packages/coding-agent/dist/bundle/cli.js --version
node packages/coding-agent/dist/bundle/cli.js --list-models

The fork reuses Pi's existing authentication under `~/.pi/agent`. If needed, run `node packages/coding-agent/dist/bundle/cli.js`, use `/login`, then exit. Choose a model your account can actually use, including its provider prefix. The model list alone is not a successful inference check; setup below runs a real turn. Never paste credentials into a task or issue. To isolate Pi's own configuration too, set `PI_CODING_AGENT_DIR` before login and throughout the trial.

**2. Configure this trial terminal.** Still at the checkout root, set the following process-local variables, replacing **`provider/model`** with your selected model. Remove any inherited per-role backend/model/runner overrides in this terminal;

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

.claude-plugin/marketplace.json · Manifest · 16 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. {
  2. "name": "argus",
  3. "owner": {
  4. "name": "Argus contributors"
  5. },
  6. "description": "Argus persistent, independently reviewed research and engineering workflows",
  7. "plugins": [
  8. {
  9. "name": "argus",
  10. "source": "./plugins/argus",
  11. "description": "Persistent reviewed research and engineering runtime",
  12. "version": "0.1.8",
  13. "category": "Productivity"
  14. }
  15. ]
  16. }
README.md · README · 872 lines · 2 findings marked

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. <div align="center">
  2. <picture>
  3. <source media="(prefers-color-scheme: dark)" srcset="docs/assets/brand/svg/argus-logo-horizontal-dark.svg">
  4. <source media="(prefers-color-scheme: light)" srcset="docs/assets/brand/svg/argus-logo-horizontal.svg">
  5. <img src="docs/assets/brand/svg/argus-logo-horizontal.svg" width="420" alt="Argus">
  6. </picture>
  7. ### Persistent, reviewed autonomy for research and engineering
  8. Long-running agent work that can plan, execute, verify, pause, and continue beyond a single model turn.
  9. **Argus v0.1.6 · Source updates and packaged desktop previews are separate channels.**
  10. [![GitHub Stars](https://img.shields.io/github/stars/lbx154/Argus?style=flat-square)](https://github.com/lbx154/Argus/stargazers)
  11. [![License](https://img.shields.io/github/license/lbx154/Argus?style=flat-square)](LICENSE)
  12. [![Python](https://img.shields.io/badge/Python-3.11%2B-3776AB?style=flat-square&logo=python&logoColor=white)](https://www.python.org/)
  13. [![arXiv](https://img.shields.io/badge/arXiv-2608.05144-b31b1b?style=flat-square&logo=arxiv&logoColor=white)](https://arxiv.org/abs/2608.05144)
  14. [Website](https://argusbot.cn) · [Video Demo](https://www.youtube.com/watch?v=i8Qy9HCboQE) · [Technical Report · arXiv:2608.05144](https://arxiv.org/pdf/2608.05144) · [WeChat Community](#wechat-community) · **English** / [简体中文](README.zh-CN.md)
  15. `Manager` → `Planner` → `Engineer` ⇄ `Reviewer`
  16. </div>
  17. ---
  18. > [!IMPORTANT]
  19. > **Repository channels:** **[microsoft/ArgusAgent](https://github.com/microsoft/ArgusAgent)**
  20. > is the official source repository;
  21. > **[lbx154/Argus](https://github.com/lbx154/Argus)** is the development preview.
  22. > Changes reach the official repository through synchronization. Installing
  23. > source from `main` is not the same as installing a published Desktop release.
  24. In this repository, **`main` is the stable source branch** and **`dev` is the
  25. development branch**. Target development PRs at `dev`; promote reviewed, validated
  26. changes to `main`. See [Contributing](CONTRIBUTING.md).
  27. ## The Driver–Harness Model
  28. A **model** is an engine: it burns compute and puts out tokens. A **harness** is the
  29. drivetrain that couples those tokens to files, shells, compilers, GPUs, and tests. The
  30. **Driver** is the seat — choosing what to do next, judging whether the last result was
  31. any good, and knowing when to stop and ask. In every other agent system that seat holds a
  32. human, which is why the work stops when they go to bed.
  33. **Argus takes the Driver's seat**, splitting it across four roles deliberately not allowed
  34. to do each other's jobs:
  35. | | Owns | May **not** |
  36. |---|---|---|
  37. | **Manager** | Stage transitions, and where an admitted lesson is kept | Perform the work it is admitting |
  38. | **Planner** | The next task, and the evidence it must produce | Move the campaign to the next stage |
  39. | **Engineer** | Implementation, research, experiments, artifacts | Declare its own work complete |
  40. | **Reviewer** | The verdict — correctness, evidence, limitations; may return `blocked` | Edit anything. It runs **read-only** |
  41. Credentials, payment, irreversible actions, and publication always stop for a human.
  42. It also improves without retraining: admitted Skills and source-linked Wiki findings are
  43. scoped `project` → `vertical` → `global` by how far they were shown to hold, and new
  44. domains ship as **verticals** against a core that does not change — seven built in and
  45. seventeen more in the community package [`argus-verticals`](https://github.com/Argus-AiTeam/argus-verticals),
  46. with zero references to the authority boundary in any of them.
  47. Because the worker cannot grade its own work, nobody has to watch it: across 27 campaigns
  48. and 1,548 hours it needed a human research decision about **once every 310 hours**, at
  49. **95–99%** duty cycle. Everything else is in the
  50. **[technical report](https://arxiv.org/pdf/2608.05144)**.
  51. **Native backends:** `GitHub Copilot CLI` · `Pi` · `OpenAI Codex CLI` · `Claude Code` · `Cursor CLI` · `OpenCode` · `Grok Build` · `Qoder` · `DeepSeek Harness`
  52. **Argus-Pi (optional preview):** We also maintain
  53. [Argus-Pi](https://github.com/Argus-AiTeam/Argus-Pi), a lightly customized fork of
  54. [Pi](https://github.com/earendil-works/pi) with small, Argus-focused improvements
  55. to task prompts, PDF reading, and execution/retry status reporting. It is available
  56. to try as a source preview; see the [trial instructions](#argus-pi-preview). It is
  57. optional, and you can continue using any of the other supported backends.
  58. Argus remains the Driver for scheduling, role assignment, and task lifecycle;
  59. Argus-Pi focuses on the Harness for model and tool execution.
  60. Ordinary Pi tasks can now [learn project runtime tools](docs/pi-runtime-learning.md):
  61. validate a reusable JSON transformation, use it in the current task, and retain its
  62. Skill and Wiki for later tasks under the existing task budget.
  63. **Harbor evaluation:** Harbor Framework can invoke the complete bounded Argus
  64. Manager/Planner/Engineer/Reviewer runtime as a custom agent. See
  65. **[Harbor integration](docs/harbor.md)**.
  66. **Coding-agent plugin:** use the packaged MCP bridge and host-specific Skills
  67. without changing the core runtime. See **[Plugin quick start](docs/plugin.md)**.
  68. **Counterexample research:** use a live
  69. Counterexample Lab, an isolated Jacobian MCP bridge, and safe in-app source
  70. updates. See **[Counterexample Lab and Jacobian setup](docs/counterexample-lab-jacobian.md)**.
  71. ## WeChat community
  72. Scan the QR code to join Argus WeChat Group 2. Click the image to open it at full
  73. size. This code is valid **before October 16, 2026**, as shown in the image.
  74. After it expires, open an Issue and ask the maintainers for the latest code.
  75. <p align="center">
  76. <a href="docs/assets/argus-wechat-group-2.png?v=20261009">
  77. <img src="docs/assets/argus-wechat-group-2.png?v=20261009" width="360" alt="Argus WeChat Group 2 QR code">
  78. </a>
  79. </p>
  80. <p align="center"><strong>Community Group 1 is full. Please join Group 2.</strong></p>
  81. ## Quick Install
  82. Choose the section for your operating system. Do not mix commands between
  83. platforms. All platforms need Node.js **22.12+** from
  84. [nodejs.org](https://nodejs.org/en/download) and one authenticated Agent CLI.
  85. Reuse the CLI you already work in; Argus does not require a separate account.
  86. Docker is not required for a normal Argus installation; it is only an optional
  87. prerequisite for the separate Harbor evaluation integration.
  88. > [!TIP]
  89. > **Recommended: let the Code Agent you already use install and verify Argus.**
  90. > Copy the prompt in the Agent-assisted section below. The manual commands remain
  91. > available for users who prefer to install each step themselves.
  92. | Agent CLI | Backend | Install | Authenticate |
  93. |---|---|---|---|
  94. | GitHub Copilot CLI | `copilot` | `npm install -g @github/copilot` | `copilot login` |
  95. | OpenAI Codex CLI | `codex` | `npm install -g @openai/codex@latest` | `codex login` |
  96. | Claude Code | `claude` | `npm install -g @anthropic-ai/claude-code` | Run `claude`, then `/login` |
  97. | Cursor CLI | `cursor` | `curl https://cursor.com/install -fsS \| bash` ([Windows](https://cursor.com/install?win32=true)) | `agent login` or `CURSOR_API_KEY` |
    • Note: Pipes a downloaded script directly into a shell (curl | sh / wget | bash)
    • Line 129 on GitHub
  98. | Pi | `pi` | `npm install -g --ignore-scripts @earendil-works/pi-coding-agent` | Run `pi`, then `/login` |
  99. | OpenCode | `opencode` | [Official install](https://opencode.ai/docs/) | `opencode auth login` |
  100. | Grok Build | `grok` | [Official install](https://x.ai/cli) | `grok login` |
  101. | Qoder CLI | `qoder` | `npm install -g @qoder-ai/qodercli` | `qodercli login` |
  102. | DeepSeek Harness | `dsh` | `npm install -g @deepseek-ai/dsh` | Configure `DEEPSEEK_API_KEY` or the dsh Models page |
  103. **Separate Copilot account for Argus:** run
  104. `argus --setup --backend copilot --copilot-home "$HOME/.copilot-argus" --copilot-login`.
  105. After setup succeeds and existing Argus processes are restarted, ordinary Argus
  106. launches use that account without changing the caller's login.
  107. See [account binding, precedence and reset](docs/agent-install.md#dedicated-copilot-account).
  108. **Research traces:** Copilot sessions are preserved by default. Opt-in session
  109. reclamation and raw I/O rotation now archive verified copies before reclaiming
  110. online files; archives do not expire automatically. Review the effective policy
  111. in Settings and monitor disk space. See [trace retention and export](docs/trace-retention.md).
  112. <a id="argus-pi-preview"></a>
  113. <details>
  114. <summary><strong>Try Argus-Pi: install, connect and roll back</strong></summary>
  115. This optional trial assumes Argus is already installed. You also need Git,
  116. Node.js **22.19+** and npm. Argus-Pi is currently a **source preview**, not a
  117. separately published npm package or desktop installer. Installing the upstream
  118. Pi npm package does not install Argus-Pi.
  119. **1. Build a separate checkout in a new terminal.** Run each command only after
  120. the previous one succeeds; do not overwrite your existing global Pi installation.
  121. ```bash
  122. git clone --branch main https://github.com/Argus-AiTeam/Argus-Pi.git
  123. cd Argus-Pi
  124. npm ci --ignore-scripts
  125. npm run hydrate:model-data
  126. npm run build:offline
  127. npm rebuild --workspace=@earendil-works/pi-coding-agent --ignore-scripts
  128. node packages/coding-agent/dist/bundle/cli.js --version
  129. node packages/coding-agent/dist/bundle/cli.js --list-models
  130. ```
  131. The fork reuses Pi's existing authentication under `~/.pi/agent`. If needed,
  132. run `node packages/coding-agent/dist/bundle/cli.js`, use `/login`, then exit.
  133. Choose a model your account can actually use, including its provider prefix.
  134. The model list alone is not a successful inference check; setup below runs a
  135. real turn. Never paste credentials into a task or issue. To isolate Pi's own
  136. configuration too, set `PI_CODING_AGENT_DIR` before login and throughout the trial.
  137. **2. Configure this trial terminal.** Still at the checkout root, set the following
  138. process-local variables, replacing **`provider/model`** with your selected model.
  139. Remove any inherited per-role backend/model/runner overrides in this terminal;
  140. they can take precedence over the shared settings. Do not put these trial settings
  141. in your shell startup files or persistent system environment.
  142. macOS / Linux:
  143. ```bash
  144. export ARGUS_SKILL_HOME="$HOME/.argus-pi-preview"
  145. export ARGUS_SKILL_RUNNER_BACKEND=pi
  146. export ARGUS_SKILL_RUNNER_BIN="$PWD/node_modules/.bin/argus-pi"
  147. export ARGUS_SKILL_MODEL="provider/model"
  148. "$ARGUS_SKILL_RUNNER_BIN" --version
  149. mkdir -p "$HOME/argus-pi-preview-workspace"
  150. cd "$HOME/argus-pi-preview-workspace"
  151. git init -q
  152. ```
  153. Windows PowerShell:
  154. ```powershell
  155. $env:ARGUS_SKILL_HOME = "$HOME\.argus-pi-preview"
  156. $env:ARGUS_SKILL_RUNNER_BACKEND = "pi"
  157. $env:ARGUS_SKILL_RUNNER_BIN = (Resolve-Path ".\node_modules\.bin\argus-pi.cmd" -ErrorAction Stop).Path
  158. $env:ARGUS_SKILL_MODEL = "provider/model"
  159. & $env:ARGUS_SKILL_RUNNER_BIN --version
  160. New-Item -ItemType Directory -Force "$HOME\argus-pi-preview-workspace" | Out-Null
  161. Set-Location "$HOME\argus-pi-preview-workspace"
  162. git init -q
  163. ```
  164. Use a new, empty trial workspace, not a production project or the Argus-Pi
  165. checkout. The backend name remains **`pi`**; the explicit executable path selects
  166. the fork. The separate Argus state directory keeps trial configuration and
  167. missions apart from your normal installation. This is **not a filesystem sandbox**.
  168. **3. Verify, then launch.** In that same terminal and workspace, run the following
  169. one at a time. Stop on any error; do not continue to the next command.
  170. ```bash
  171. argus --setup --backend pi --non-interactive
  172. argus --backend pi doctor --deep --advisor none
  173. argus --config-help
  174. argus
  175. ```
  176. Check that `ARGUS_SKILL_RUNNER_BIN` points into your Argus-Pi checkout. Start with
  177. a small, reversible task confined to the trial workspace. Setup, deep diagnostics
  178. and tasks can consume your provider's quota or paid usage; "preview" does not mean
  179. free inference.
  180. **4. Stop and roll back.** After leaving the UI, keep the trial terminal's
  181. environment and working directory and run:
  182. ```bash
  183. argus --daemon-stop --drain
  184. argus --status
  185. ```
  186. Wait for the trial daemon to stop, then close that terminal and use your normal
  187. Argus launch command in a fresh terminal. If the trial terminal was already closed,
  188. restore its `ARGUS_SKILL_HOME` and workspace before issuing the stop command.
  189. Closing a terminal alone does not guarantee that background work has stopped.
  190. There is no need to uninstall upstream Pi or delete the trial records.
  191. `PI_HARNESS_PROFILE=stock` switches compatibility behavior inside the fork; it is
  192. **not** a replacement for returning to the original executable.
  193. </details>
  194. **Choose your installation channel.** The commands below install the official
  195. source repository's `main` branch directly from GitHub, not from PyPI. To
  196. deliberately install the development preview, replace `microsoft/ArgusAgent`
  197. with `lbx154/Argus` in your platform's install and update commands. Keep the same
  198. channel when updating an existing installation.
  199. For a Windows EXE, use **[Windows Desktop](docs/windows-desktop.md)**. Official
  200. release assets, when available, are under
  201. [microsoft/ArgusAgent Releases](https://github.com/microsoft/ArgusAgent/releases);
  202. packaged previews are under
  203. [lbx154/Argus Releases](https://github.com/lbx154/Argus/releases).
  204. Source fixes do not update an already published EXE.
  205. ### Recommended: Agent-assisted installation
  206. Send this prompt to an already installed Code Agent:
  207. ```text
  208. Read https://github.com/microsoft/ArgusAgent/blob/main/docs/agent-install.md and
  209. install the official source unless I explicitly request the development preview.
  210. Keep an existing installation's channel when updating. Use the section for this
  211. operating system. Prefer the Agent CLI running
  212. this conversation as the Argus backend. Do not create a venv on Windows or
  213. macOS; keep the documented venv on Linux. Run setup through its real Agent-turn
  214. smoke test, then run `argus doctor --deep --advisor auto`. Before account login,
  215. sudo, or global configuration changes, explain why and wait for approval. Never
  216. ask me to paste a password, token, or API key into the conversation.
  217. ```
  218. The agent follows the **[installation execution contract](docs/agent-install.md)**.
  219. ### Windows 10/11 — direct pip, no virtual environment
  220. Install Python 3.11+ from [python.org](https://www.python.org/downloads/windows/)
  221. and select **Add Python to PATH** in the installer. Then open a new PowerShell:
  222. ```powershell
  223. py --version
  224. node --version
  225. py -m pip install --upgrade pip
  226. py -m pip install --upgrade --force-reinstall "argus @ https://github.com/microsoft/ArgusAgent/archive/refs/heads/main.zip"
  227. $Scripts = py -c "import sysconfig; print(sysconfig.get_path('scripts'))"
  228. $Argus = Join-Path $Scripts "argus.exe"
  229. if (-not (Test-Path $Argus)) { throw "Argus entry point not found at $Argus" }
  230. $env:Path = "$Scripts;$env:Path"
  231. & $Argus --version
  232. & $Argus --setup
  233. & $Argus doctor --deep --advisor auto
  234. & $Argus --status
  235. & $Argus
  236. ```
  237. Calling `$Argus` proves setup is not accidentally using another stale
  238. installation. `$env:Path` also makes plain `argus` available in the current
  239. PowerShell. The troubleshooting section covers persistent PATH repair.
  240. `argus doctor` is read-only by default. To explicitly authorize an installed
  241. Agent CLI to inspect and repair Argus-scoped files, configuration, runtime
  242. state, or dependencies, use `argus doctor --advisor auto` (or name a specific
  243. advisor). Use `argus doctor --advisor none --verify` for deterministic,
  244. no-model verification. An explicitly requested active repair may take several
  245. minutes because it performs a real Agent turn; it is not a quick version check.
  246. Windows currently supports installation, Manager chat, pairing, Web/TUI,
  247. terminal-scoped daemon control, and native durable subagents. On native Windows,
  248. a detached worker owns direct or supervised long commands, persists registry and
  249. log state, and uses bounded process-tree cleanup; WSL2 remains optional rather
  250. than required for this path. The Windows Desktop installer is documented separately in
  251. **[Windows Desktop](docs/windows-desktop.md)**.
  252. ### macOS — managed command install, no manual virtual environment
  253. Install [uv](https://docs.astral.sh/uv/getting-started/installation/) if needed,
  254. then:
  255. ```bash
  256. uv --version
  257. node --version
  258. uv tool install --force --python 3.12 \
  259. "argus @ https://github.com/microsoft/ArgusAgent/archive/refs/heads/main.zip"
  260. ARGUS_BIN="$(uv tool dir --bin)/argus"
  261. test -x "$ARGUS_BIN"
  262. "$ARGUS_BIN" --version
  263. uv tool update-shell
  264. "$ARGUS_BIN" --setup
  265. "$ARGUS_BIN" doctor --deep --advisor auto
  266. "$ARGUS_BIN" --status
  267. "$ARGUS_BIN"
  268. ```
  269. `ARGUS_BIN` works immediately even when uv's tool directory was not previously
  270. on PATH. `uv tool update-shell` makes plain `argus` available in a new terminal.
  271. `uv tool` already owns the isolated environment; do not create another venv.
  272. ### Linux — isolated source venv
  273. Linux servers keep an explicit venv so Python, CUDA tooling, and long-running
  274. process ownership remain reproducible. Install Python 3.11+, Git, Node.js
  275. 22.12+, and your distribution's `python3-venv` package first:
  276. ```bash
  277. git clone https://github.com/microsoft/ArgusAgent.git "$HOME/Argus"
  278. cd "$HOME/Argus"
  279. python3 -m venv .venv
  280. .venv/bin/python -m pip install --upgrade pip
  281. .venv/bin/python -m pip install -e .
  282. ARGUS_BIN="$HOME/Argus/.venv/bin/argus"
  283. "$ARGUS_BIN" --version
  284. "$ARGUS_BIN" --setup
  285. "$ARGUS_BIN" doctor --deep --advisor auto
  286. "$ARGUS_BIN" --status
  287. "$ARGUS_BIN"
  288. ```
  289. Private-preview collaborators use
  290. `https://github.com/lbx154/argus-skill.git` in the Linux clone command. On
  291. Windows/macOS, install a private wheel or authenticated private archive rather
  292. than putting a GitHub token in shell history.
  293. Do not rely on a globally installed `argus` on Linux. In a new shell, use
  294. `$HOME/Argus/.venv/bin/argus` (or activate that venv explicitly). If venv
  295. creation reports that `ensurepip` is unavailable, install the distribution's
  296. `python3-venv` package and rerun the command.
  297. ### Backend notes
  298. Use `copilot`, `pi`, `codex`, `claude`, `cursor`, `opencode`, `grok`, `qoder`, or `dsh`
  299. for `--backend`. Setup adopts a model from the selected CLI's own catalog when
  300. one is available; otherwise it keeps that CLI's native default. It does not
  301. inject an OpenAI model id into Claude Code, Cursor CLI, Pi, OpenCode, Grok, Qoder, or dsh.
  302. If you have an OpenAI-compatible endpoint, setup installs Pi when needed and
  303. configures it directly:
  304. ```bash
  305. ARGUS_SETUP_API_KEY=... argus --setup --non-interactive \
  306. --api-url https://api.example.com/v1 \
  307. --api-model model-id
  308. ```
  309. For Grok Build, install and authenticate the official xAI CLI first:
  310. ```bash
  311. curl -fsSL https://x.ai/cli/install.sh | bash
    • Note: Pipes a downloaded script directly into a shell (curl | sh / wget | bash)
    • Line 389 on GitHub
  312. grok login
  313. argus --setup --non-interactive --backend grok
  314. ```
  315. `XAI_API_KEY` is also supported for headless environments. Argus uses Grok's
  316. native headless JSON stream, resumes sessions by ID, and keeps role prompts out
  317. of process arguments.
  318. In PowerShell, use a backtick instead of `\` for line continuation.
  319. #### Choosing a provider on the multi-provider CLIs
  320. Pi and OpenCode are provider-agnostic fronts: which account they bill depends on
  321. what you authenticated them against (a native DeepSeek key, Anthropic, Azure, a
  322. local vLLM, a Copilot proxy). Argus passes your configured model id straight
  323. through, so a bare id like `deepseek-chat` is resolved by the CLI itself.
  324. Name the provider when a bare id is ambiguous or when the CLI requires it:
  325. ```bash
  326. # Pi — only needed when two authenticated catalogs carry the same model id
  327. export ARGUS_SKILL_PI_PROVIDER=deepseek
  328. # OpenCode — required: `opencode run --model` only accepts provider/id
  329. export ARGUS_SKILL_OPENCODE_PROVIDER=deepseek
  330. ```
  331. Both are also settable from the cockpit `/config` view, and persist across
  332. restarts once set there.
  333. `argus --doctor` reads the CLI's authenticated catalog and tells you when the
  334. configured provider is not one you hold a key for, or when a model id you
  335. selected is not on offer.
  336. Use `argus --config-help` to inspect each role's effective model and where it
  337. came from. Catalog commands are backend-specific, for example
  338. `pi --list-models`, `opencode auth list`, and `qodercli --list-models`.
  339. Full details, including the breaking change for Pi deployments that relied on
  340. the old implicit `github-copilot` prefix: **[backend providers](docs/backend-providers.md)**.
  341. ### Launch
  342. Windows and macOS can use `argus` after PATH setup. On Linux, replace `argus`
  343. below with `$HOME/Argus/.venv/bin/argus` unless the venv is active.
  344. ```bash
  345. argus
  346. ```
  347. ```bash
  348. argus doctor # deterministic, read-only diagnostics
  349. argus doctor --advisor auto # explicitly request Agent-driven inspection and repair
  350. argus doctor --advisor none --verify # deterministic verification, no model call
  351. argus --status # inspect the current runtime
  352. ```
  353. ## Interfaces
  354. ### Windows Desktop
  355. The Windows x64 source tree includes a Tauri/Rust host that supervises a frozen
  356. copy of the same Argus runtime and opens the existing Web cockpit—there is no
  357. separate Desktop fork of Manager, Workbench, or the WebAPI. It also provides
  358. signed update discovery and user-confirmed installation. Source setup, security
  359. boundaries, verification, and packaging commands are documented in
  360. **[Windows Desktop](docs/windows-desktop.md)**.
  361. ### Terminal cockpit
  362. ```bash
  363. argus
  364. ```
  365. Use the terminal cockpit to talk to the Manager, follow live work, inspect state, and resume projects.
  366. Without an explicit `--port`, Argus reuses a compatible backend or selects the
  367. first available port starting at `8799` when another program or stale backend
  368. occupies it. On Windows, a plain `argus` launch also opens the Web UI; use
  369. `argus --no-open` for the terminal cockpit only.
  370. ### Web UI
  371. Start Argus and open the Web UI in your default browser:
  372. ```bash
  373. argus --web
  374. ```
  375. Preferred address: [http://127.0.0.1:8799](http://127.0.0.1:8799); Argus advances
  376. to the next available port when needed.
  377. The Web UI follows the browser language on first launch and supports English
  378. and Simplified Chinese. Use the language button in the session sidebar to
  379. switch; the selection is saved in the browser.
  380. ```bash
  381. argus --web --web-port 8800 # use another port
  382. ```
  383. #### Remote server over SSH
  384. Background project daemons continue after the client disconnects. For unattended
  385. operation, automatic restart and boot startup, see [daemon lifecycle and service
  386. supervision](docs/daemon-lifecycle.md).
  387. On the server:
  388. ```bash
  389. argus --web
  390. ```
  391. On your computer:
  392. ```bash
  393. ssh -L 8799:127.0.0.1:8799 user@server
  394. ```
  395. Then open [http://127.0.0.1:8799](http://127.0.0.1:8799) locally.
  396. <details>
  397. <summary><strong>Direct LAN access</strong></summary>
  398. A non-loopback bind is always protected by a bearer token. If
  399. `ARGUS_SKILL_WEB_TOKEN` is set it is used; otherwise one is minted for that run:
  400. ```bash
  401. argus --web --web-host 0.0.0.0 --web-port 8799
  402. ```
  403. This prints the address other devices can reach, the token, and a QR code.
  404. Set the token yourself to keep one across restarts:
  405. ```bash
  406. export ARGUS_SKILL_WEB_TOKEN="$(python -c 'import secrets; print(secrets.token_urlsafe(32))')"
  407. ```
  408. To serve without a token — only behind your own authenticating proxy — set
  409. `ARGUS_SKILL_WEB_ALLOW_INSECURE=1`.
  410. </details>
  411. ### From a phone
  412. Telegram, Feishu/Lark, and the web UI all work from a phone. The two chat bots
  413. dial out, so a daemon behind NAT needs no tunnel and no public URL:
  414. ```bash
  415. # Feishu / Lark — WebSocket long connection, no request URL to configure
  416. pip install 'argus[feishu]'
  417. export ARGUS_SKILL_ENABLE_FEISHU=1
  418. export ARGUS_SKILL_FEISHU_APP_ID=cli_xxx ARGUS_SKILL_FEISHU_APP_SECRET=xxx
  419. # Telegram
  420. export ARGUS_SKILL_ENABLE_TELEGRAM=1
  421. export ARGUS_SKILL_TELEGRAM_BOT_TOKEN=... ARGUS_SKILL_TELEGRAM_CHAT_ID=...
  422. ```
  423. Both bots serve the same commands (`/add`, `/status`, `/nudge`, `/backlog`, …).
  424. The web UI is installable to the home screen and pairs by scanning the QR code
  425. printed by `argus --web --web-host 0.0.0.0`.
  426. See **[docs/mobile.md](docs/mobile.md)** for the full setup.
  427. ## Advanced usage
  428. Argus is designed to be changed, not merely configured.
  429. ### Autonomy level
  430. The default `pragmatic` mode handles recoverable engineering choices—timeouts, failed tests, benchmark sizing, and technical routes—without interrupting you. It asks only for credentials, more spending, irreversible/outward-facing actions, or changes to an operator-owned acceptance boundary.
  431. ```bash
  432. export ARGUS_SKILL_AUTONOMY_MODE=cautious # ask on every explicit question
  433. export ARGUS_SKILL_AUTONOMY_MODE=pragmatic # default: recover technical issues
  434. export ARGUS_SKILL_AUTONOMY_MODE=autonomous # maximize reversible execution
  435. ```
  436. The Web configuration view and `/config` expose the same setting.
  437. ### Adapt the runtime
  438. 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.
  439. The compact constitution behind those choices is **[Argus Principles](docs/PRINCIPLES.md)**:
  440. agents judge meaning while the runtime guarantees mechanics; Core provides capability while
  441. Verticals provide policy; thought stays natural language; tokens buy information or action;
  442. exploration pursues upside while claims remain evidence-bound; failure changes strategy;
  443. programme outcomes and end-to-end evidence judge progress.
  444. One worked engineering case is **[exploration without local hill climbing](docs/exploration-without-local-hill-climbing.md)**: how report-only research, high-risk mechanism portfolios, single-run screening, and strict final claims were separated after an MI300X serving campaign exposed overly conservative incentives.
  445. For the wider set, **[what goes wrong and what we did about it](docs/failure-modes-and-fixes.md)** records six real failure modes — an experiment that measured its own token cap, world knowledge frozen at the training cut-off, settling for finishing rather than achieving something, ceremony applied before an idea had earned it, local hill climbing, and a reluctance to report a win. It also records a fix we got wrong: adding a gate to enforce ambition, when the honest answer was that defensive checks do not produce good work, they produce work that passes checks.
  446. A measured counterpart is **[system audit: six complaints, checked against the code](docs/system-audit.md)** — over-defensiveness, a rigorous verification bar, unnecessary operator questions, weak instruction following, redundancy, and schema abuse, each confirmed or refuted with counts from the tree.
  447. The follow-up **[architecture simplification plan](docs/architecture-simplification-plan.md)** separates a short direct-engineering lane from the full research team, proposes one Host-generated shared mission view, and outlines a compatibility-first Vertical package split.
  448. Maintainers can use the **[runtime maintenance map](docs/runtime-maintainability.md)** for code entry points, state ownership, recovery boundaries, and the current refactoring tasks.
  449. What follows from that audit is **[the simplification plan](docs/simplification-plan.md)**: an ordered set of deletions, a mechanical rule for sorting 2,277 exception handlers, an explicit list of what must not be removed, and the trap to avoid — replacing deleted machinery with a unified system that becomes the same mistake.
  450. ### Verticals
  451. Seven verticals ship with Argus itself: `research`, `software`, `argus_maintenance`,
  452. `kernel_engineering`, `math`, `math_synth`, `learning`. The other seventeen — `quant`,
  453. `speedrun`, `kernelbench`, `nanochat`, `nanogpt_speedrun`, `chip_design`, `digital_circuit`,
  454. `digital_circuit_benchmark`, `medical`, `materials`, `physics`, `ale_last_exam`,
  455. `fiction_writing`, `prose`, `modern_poetry`, `classical_poetry`, `literary_editor` — live in
  456. the community repository **[argus-verticals](https://github.com/Argus-AiTeam/argus-verticals)**.
  457. The **Vertical Store** installs them one at a time, without `pip`, from the repository's
  458. releases — in the cockpit's Verticals page or on the command line:
  459. ```bash
  460. argus verticals list # built-in, installed, and available verticals
  461. argus verticals install materials # download, verify sha256, unpack under ~/.argus-skill/verticals
  462. argus verticals install chip_design # brings digital_circuit with it (declared `requires`)
  463. argus verticals remove chip_design # digital_circuit stays
  464. ```
  465. The store shows a vertical's Python requirements and flags the missing ones; it never
  466. installs them. Details, the on-disk layout, hosted mode and the API are in
  467. **[docs/vertical-store.md](docs/vertical-store.md)**. The whole package can still be
  468. installed with pip into the Python environment that runs Argus (`pip install
  469. "argus-verticals @ git+https://github.com/Argus-AiTeam/argus-verticals.git"`); a
  470. pip-installed copy wins over the store for a vertical both provide. A `git pull` of
  471. Argus never installs community verticals either way.
  472. ### Build your own Vertical
  473. 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.
  474. The `math` vertical is the worked example: three stages, a content-addressed
  475. evidence store, Lean-backed mechanical verification, and an explicit rule for
  476. which kind of check is allowed to settle which kind of question. See
  477. **[mathematical research](docs/research-mathematics.md)**.
  478. ### Use another agent as the outer layer
  479. GitHub Copilot, Pi, Codex, Claude Code, Cursor CLI, OpenCode, Grok Build, 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.
  480. - **Native Argus backends:** GitHub Copilot CLI, Pi, Codex CLI, Claude Code, Cursor CLI, OpenCode, Grok Build, Qoder, DeepSeek Harness
  481. - **External agent operators:** OpenClaw, Hermes, or any agent that can use a shell or HTTP API
  482. For durable missions, install or adapt the portable
  483. [`argus-runtime-orchestration` Agent Skill](integrations/agent-skills/argus-runtime-orchestration/SKILL.md).
  484. It defines the two-party operator model, the active `Needs you` intervention loop,
  485. host-specific adapters, evidence boundaries, and closeout checks.
  486. Useful entry points:
  487. ```bash
  488. argus doctor
  489. argus --status
  490. argus --web
  491. ```
  492. The most capable setup is often an Argus instance deliberately adapted to your own ambitious field and way of working.
  493. ## Update
  494. For source checkouts, pip ZIP installations, and uv-managed installations, use
  495. the installed Argus command:
  496. ```bash
  497. argus update
  498. argus --version
  499. argus doctor --advisor none --verify
  500. ```
  501. `argus --update` and `argus -update` are equivalent aliases. The updater keeps
  502. the installation's existing source and channel, uses its package manager, and
  503. does not switch between the official and preview repositories. Source checkouts
  504. must be clean and on a branch; updates only fast-forward.
  505. If `argus` is not on PATH, use the executable from installation: `& $Argus update`
  506. in Windows PowerShell, `"$(uv tool dir --bin)/argus" update` for uv, or
  507. `"$HOME/Argus/.venv/bin/argus" update` for the Linux source checkout.
  508. Older versions do not yet include this updater. Bootstrap once with the
  509. original installation command below, keeping the original repository URL
  510. (replace `microsoft/ArgusAgent` with `lbx154/Argus` for an existing preview
  511. installation). Subsequent upgrades can use `argus update`.
  512. Windows bootstrap:
  513. ```powershell
  514. py -m pip install --upgrade --force-reinstall "argus @ https://github.com/microsoft/ArgusAgent/archive/refs/heads/main.zip"
  515. $Argus = Join-Path (py -c "import sysconfig; print(sysconfig.get_path('scripts'))") "argus.exe"
  516. & $Argus --version
  517. & $Argus doctor --advisor none --verify
  518. ```
  519. macOS bootstrap:
  520. ```bash
  521. uv tool install --force --python 3.12 \
  522. "argus @ https://github.com/microsoft/ArgusAgent/archive/refs/heads/main.zip"
  523. "$(uv tool dir --bin)/argus" --version
  524. "$(uv tool dir --bin)/argus" doctor --advisor none --verify
  525. ```
  526. Source-checkout bootstrap (inspect local changes first):
  527. ```bash
  528. git -C "$HOME/Argus" status --short
  529. git -C "$HOME/Argus" pull --ff-only
  530. "$HOME/Argus/.venv/bin/python" -m pip install -e "$HOME/Argus"
  531. "$HOME/Argus/.venv/bin/argus" --version
  532. "$HOME/Argus/.venv/bin/argus" doctor --advisor none --verify
  533. ```
  534. Only continue the source bootstrap when `git status --short` is empty and the
  535. branch tracks the intended repository. Argus detects stale local WebAPI and
  536. daemon processes and replaces them at a controlled task boundary. Verification
  537. with `--advisor none --verify` does not spend a model call.
  538. Packaged Desktop EXEs use the separate signed desktop update channel. The CLI
  539. updater does not replace a signed EXE; see [Windows Desktop](docs/windows-desktop.md).
  540. ## Renamed: argus-skill → argus
  541. On 2026-09-14 the Python package `argus_skill` became `argus`, the pip
  542. distribution `argus-skill` became `argus`, and the `argus-skill` command was
  543. folded into `argus`. `argus` was already the cockpit launcher; its admin flags
  544. and subcommands (`argus --status`, `argus doctor`, `argus --daemon`,
  545. `argus --web --web-host H --web-port P`, ...) now reach the Python CLI, while
  546. mission-start and daemon-client flags (`--objective`, `--resume`, `--continue`,
  547. `--new`, `--drain`, `--trial`, `--json`, `--host/--port`) still belong to the
  548. cockpit. Headless automation should call `python -m argus ...`: the plain
  549. command-line interface, which never starts the Node cockpit.
  550. **What did not change.** Every `ARGUS_SKILL_*` environment variable and knob
  551. (the keys in `~/.argus-skill/config.json`), the state root `~/.argus-skill`
  552. with its projects, seeded Skills and logs, the Web API's `argus-skill-webapi`
  553. service id, and the other on-disk markers (`/tmp/argus-skill-role-slots`,
  554. `~/argus-skill-tasks`, `~/.local/share/argus-skill`, ...). Nothing under
  555. `~/.argus-skill` moves.
  556. **Kept for one release.** `import argus_skill` is the same package object as
  557. `import argus` (a two-file alias, not a copy), `python -m argus_skill ...` runs
  558. the same modules, the `argus-skill` command still exists and prints one
  559. deprecation line on stderr, teammates and trial containers started under the
  560. old name are still recognised, and community verticals registered under the
  561. pre-rename entry-point group are still discovered (with a warning).
  562. **Migrating an install.** Uninstall the old distribution before installing the
  563. new one, then restart any running daemon or `--web` server:
  564. ```bash
  565. # editable checkout (Linux / macOS venv)
  566. "$HOME/Argus/.venv/bin/python" -m pip uninstall -y argus-skill && "$HOME/Argus/.venv/bin/python" -m pip install -e "$HOME/Argus"
  567. ```
  568. ```bash
  569. # macOS uv tool
  570. uv tool uninstall argus-skill
  571. uv tool install --force --python 3.12 \
  572. "argus @ https://github.com/microsoft/ArgusAgent/archive/refs/heads/main.zip"
  573. ```
  574. `argus update` on a pip install that is still named `argus-skill` does the
  575. uninstall itself; a `uv tool` environment under the old name is refused with
  576. the two commands above. The name `argus` on PyPI belongs to an unrelated
  577. project: Argus is installed from Git, as everywhere in this README.
  578. A cockpit launched right after the upgrade may still find the Web API that the
  579. old `argus-skill` launcher started. It treats `argus` and `argus-skill` in the
  580. same venv as the same backend, so its ownership record keeps working; if it
  581. nevertheless reports `incompatible Argus API at <host>:<port>: ... — ownership
  582. could not be proven`, stop the old `--web` backend (its PID is recorded in
  583. `~/.argus-skill/runtime/webapi-<host>-<port>.owner.json`; `kill <pid>`) or
  584. start the cockpit on another port.
  585. ## Uninstall
  586. ```powershell
  587. # Windows
  588. py -m pip uninstall argus
  589. ```
  590. ```bash
  591. # macOS
  592. uv tool uninstall argus
  593. ```
  594. On Linux, stop Argus, preserve any work you need, then remove the
  595. `$HOME/Argus` checkout and its `.venv`. Package removal intentionally leaves
  596. runtime state under `$HOME/.argus-skill` untouched on every platform; delete
  597. that directory only when you also want to remove projects, configuration, and
  598. logs.
  599. ## Installation troubleshooting
  600. - Unknown prices or missing usage remain visible for reconciliation; they do
  601. not block new calls or interrupt running calls, and are not treated as free.
  602. Argus rechecks late or partial Copilot billing and prices pending token
  603. records when their recorded model and complete token counts can be priced.
  604. Known settled and observed in-flight spend still enforce the global daily
  605. budget; provider rate limits and the trial key's server quota still apply.
  606. Check the provider, model and reason in
  607. `cost-control.json` under the Argus data directory and the project's
  608. `usage.jsonl`; do not delete the ledger. Run diagnostic commands in a terminal,
  609. not in the Web chat box.
  610. - Confirm which executable the shell is using: `Get-Command argus -All` on
  611. PowerShell, or `type -a argus` on macOS/Linux. Its `argus --version` release
  612. id should change after an update.
  613. - On macOS, use `"$(uv tool dir --bin)/argus"` immediately. Run
  614. `uv tool update-shell` once and open a new terminal for plain `argus`.
  615. - On Windows, recover the exact Scripts directory with
  616. `$Scripts = py -c "import sysconfig; print(sysconfig.get_path('scripts'))"`.
  617. Add it to the current window with `$env:Path = "$Scripts;$env:Path"`. For new
  618. windows, use the Python installer’s **Modify** action and enable
  619. **Add Python to PATH** rather than creating a venv.
  620. - On Linux, use `$HOME/Argus/.venv/bin/argus`; a global `argus` may be an older
  621. installation. Install `python3-venv` if `python3 -m venv` lacks `ensurepip`.
  622. - Use `argus doctor --advisor none --verify` for deterministic diagnostics.
  623. Use `argus doctor --advisor auto` when you explicitly want an installed
  624. Agent to inspect and repair Argus directly.
  625. - Use `argus --config-help` to check the effective backend/model before blaming
  626. setup or authentication.
  627. ## Repository layout
  628. - `argus/` — the Python package; everything `argus`, `argus` and the daemon run.
  629. - `argus/core/`, `proof_ledger/` — kernel: models, ports, contracts, paths. Intended leaf: must import nothing above itself; today's remaining upward edges are pinned in the invariants test (`tests/test_architecture_invariants.py`) and removed in phase 1.
  630. - `argus/agent_cli/`, `adapters/`, `provider_integrations/`, `advisor/` — drivers for the model CLIs (codex, claude, copilot, ...).
  631. - `argus/skills/`, `tools/`, `wiki/`, `cli/` — capabilities: the Skill library, operator-approved tools, the project Wiki, terminal rendering.
  632. - `argus/verticals/`, `domains/`, `builtin_skills/` — domain knowledge: the 7 built-in verticals (17 more arrive as entry points from `argus-verticals`), overlays, seeded Skills.
  633. - `argus/roles/`, `planner/`, `engineer/`, `reviewer/` — the persistent roles: the prompt catalog (`roles/`) plus the Planner, Engineer and Reviewer code (the Manager's code is in `manager/`).
  634. - `argus/life/`, `manager/`, `messaging/` — runtime: project memory, backlog, supervisor, the Manager control plane, cross-project messages.
  635. - `argus/daemon/`, `team/` — the detached 7x24 worker and agent teams.
  636. - `argus/apps/`, `webapi/`, `plugin/`, `maintenance/`, `trial/` — delivery: CLI, web API, host plugin, Doctor, hosted trial.
  637. - `frontend/` — Ink terminal cockpit (`tui`), React web cockpit (`web`), shared TypeScript (`core`).
  638. - `desktop-tauri/` — Tauri desktop shell (Windows release; four CI targets); `plugins/` — installable host plugin; `tests/` — pytest suite.
  639. See [docs/LAYOUT.md](docs/LAYOUT.md) for the full map and the declared layering.
  640. ## What Argus has done so far
  641. A partial record, grouped by **who decides whether the result counts** — and none of
  642. those deciders is Argus.
  643. ### Open code
  644. | Repository | Result |
  645. |---|---|
  646. | **[ace-2](https://github.com/Argus-AiTeam/ace-2)** | A Qwen2.5-0.5B W4A8 inference accelerator with no human author of record for its spec, RTL, verification, or physical flow. **13,914/13,914** runtime commands; SKY130 at **0.614 mm²** (cap 2.0), **+0.6966 ns** slack, WNS/TNS 0.00 ns, 100 MHz. The certificate publishes its own exclusions: no DRC/LVS, no GDS, no silicon. |
  647. | **[minimax-h3-mac](https://github.com/Argus-AiTeam/minimax-h3-mac)** · **[-desktop](https://github.com/Argus-AiTeam/minimax-h3-desktop)** · **[ComfyUI nodes](https://github.com/Argus-AiTeam/ComfyUI-MiniMax-H3-MLX)** | A ~62 GiB model, not shrunk but run: **47 min 58.7 s** at **~15.8 GB** peak on a 24 GB M4 Pro. On one RTX A6000, Turbo 8-step reaches **6.159×** over a BF16 N=10 baseline. Candidates that failed the quality gate are published as *rejected*. |
  648. | **[FlashDA](https://github.com/SJTU-DENG-Lab/FlashDA/tree/feature/dllm-fa4-adaptation)** · **[Diffulex](https://github.com/SJTU-DENG-Lab/Diffulex)** | Six diffusion-LM mask families carried into a **FlashAttention-4 CuTe DSL** kernel in **21.85 hours** of model compute, under **80 CNY**, with 2 interruptions in 87.7 hours. **19/19** parity across SM80/SM90; on H200/SM90 it reaches **92–95% of native FA4** and **1.61–2.57×** over the Diffulex Triton backend, both sides CUDA-Graph captured. The early route was **4.9–29.6× slower** than native; recognising the data path was wrong and abandoning it is what produced the result, and that rejected route is retained with its evidence. |
  649. FlashDA builds on the excellent FlashAttention-4 / CuTe DSL work by
  650. [Tri Dao](https://github.com/tridao) and collaborators. Reproductions and ports beyond
  651. SM90 are very welcome; the full protocol and per-scenario latencies are in
  652. [`EXPERIMENT_RESULTS.md`](https://github.com/SJTU-DENG-Lab/FlashDA/blob/feature/dllm-fa4-adaptation/EXPERIMENT_RESULTS.md).
  653. ### Judged by outside maintainers
  654. | Submission | Outcome |
  655. |---|---|
  656. | **[sglang#35038](https://github.com/sgl-project/sglang/pull/35038)** — native SenseNova U1 multimodal generation and interleave serving | 36 files, **+11,263/−72**, 14 commits. 1,116 tensors, 0 missing; VQA exact **160/160**; concurrency-8 exact **8/8**; **5.108×** at BS8. One engineer with a turn-by-turn agent invested **60+ hours** without completing it; Argus finished inside **24.14 hours**. *Open.* |
  657. | **[fla-org#1045](https://github.com/fla-org/flash-linear-attention/pull/1045)** — TileLang RWKV6 backend | **Merged**, 1.21× fwd+bwd on H100 NVL, no inline change requests. Its description states the work was completed autonomously — and an outside maintainer accepted that sentence with the code. |
  658. | **[fla-org#1109](https://github.com/fla-org/flash-linear-attention/pull/1109)** — SM100 autotune crash | **Merged.** Two lines, no speedup: before the fix the test file could not finish; after it, **76 tests pass**. |
  659. | **[fla-org#1128](https://github.com/fla-org/flash-linear-attention/pull/1128)** · **[#1114](https://github.com/fla-org/flash-linear-attention/pull/1114)** | KDA training 1.29× over Triton, and `AttnRes` 1.102× geomean on B200. Both report their *worst* row alongside the mean, and #1128 shipped the 1.078–1.099× number it could verify rather than the 1.541× it measured. *Open.* |
  660. ### Scored by official harnesses
  661. | Arena | Result |
  662. |---|---|
  663. | SWE-Bench Pro (731 tasks) | **≈78%** vs **59%** for direct Copilot, same model both sides — and **35** tasks declared `blocked` rather than reported as unsupported successes |
  664. | SOL-ExecBench | Rank **#6 globally**; 7 kernels top-3; beat the #1 entrant on 2 |
  665. | MLE-Bench Lite | **69.2%** medal rate (9/13): 3 gold, 3 silver, 3 bronze, against Kaggle leaderboards |
  666. | AARRI-Bench | **63/82 (76.8%)** vs 68.3% paper best |
  667. | nanochat / nanoGPT speedrun | 0.9636 vs 0.9646 BPB on B200; **79.77 s** vs 80.18 s same-device human record |
  668. ### Decided by external checkers
  669. - **MOF generation** — chemical control 92.5 / 100.0 / 74.5%, AUC 0.594 → 0.833, verified by external `MOFChecker`. The admitted method is *smaller* than the one it replaces.
  670. - **Erdős–Gyárfás** — six proof-backed frontier updates, with one falsified route retained as evidence rather than deleted.
  671. - **Research writing** — six paper pipelines to submission across 254 missions, including 16 Stage rollbacks under review.
  672. - **On itself** — at maturity, **21% fewer tokens** and **15% less active time** per solved SWE-Bench Pro task than at startup, with weights unchanged. Longest single campaign: **8.1 days**.
  673. > [!NOTE]
  674. > Every number is reproduced from the [technical report](https://arxiv.org/pdf/2608.05144)
  675. > or the linked repository, and carries the scope conditions stated there.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.