ArgusAI

Give the Agent a goal. Let it do the work in ArgusAI.
Local workspace · Long autonomous runs · Proactive defense · Continuous security exercises

Documentation (中文) · Quick start · Architecture · In action · Automation · Releases · 简体中文 · Website

Agent across the workbench

ArgusAI is an Agent-native security workbench open-sourced by DAWA Technology (达瓦科技). It puts an AI assistant, scan tasks, browsers, proxy traffic, reverse engineering samples and evidence in a local workspace, supporting internal-network defense, application defense, attack tracing and continuing security exercises through material review, controlled validation, reporting and remediation testing.

Give the Agent the goal, materials and authorized scope. It organizes scanning, browser, proxy, reverse engineering, knowledge and scheduled tasks, continuing through analysis, validation and delivery. The Agent is the default entry point for work; feature pages let you observe progress, inspect evidence and intervene when needed. The GUI, CLI and Python core connect to the same application capabilities.

The full conversation entry in the sidebar and the movable floating button both open the same Agent workspace. The Agent understands the current application page, the task or reverse job being viewed, and related work state. Reference specific materials so it can continue the work in front of you. Feature pages and conversations share the same tasks, samples and evidence.

The project is intended for internal security teams, application security engineers, researchers and explicitly authorized testers. Its general Agent runtime also supports file processing, routine information work and desktop collaboration; the built-in tools and workflows currently focus on security analysis and reverse engineering.

Workbench architecture

The main Agent plans around the goal, reads Skills, discovers tools and delegates to subagents or a persistent team as needed. Tools operate on stateful work objects: the Agent can inspect their current state, continue acting on the same object, and record steps and artifacts before reviewing the results, updating the plan and delivering or moving to the next stage.

flowchart TB
    Input["Desktop / floating entry / CLI<br/>Paired chat on a phone or other device"] --> Session["Session execution control<br/>session_id / run lock / runtime binding"]
    Events["Interval / Cron<br/>Webhook / file changes"] --> Session
    Session --> Native["AssistantSession<br/>Native endpoints / streaming provider<br/>Tool loop / progress guards"]
    Session --> ACP["Local Agent via ACP<br/>Codex / Cursor<br/>Claude Code"]
    Native --> Main["Main Agent / task coordination<br/>Plan, delegate and call tools<br/>Review state and results"]
    ACP --> Main

    Main -->|Delegate / collect results| Sub["Temporary subagents<br/>Separate history / workbench tool scope<br/>Native or ACP workers"]
    Main -->|Coordinate / review| Team["Persistent Agent Team<br/>Message sequence / read cursors<br/>Member execution inboxes"]
    Main -->|Read as needed| Skills["Skills<br/>Task methods and workflows"]
    Main --> Tools["Frozen tools[] / catalog<br/>Discover / invoke tools<br/>Query state / continue"]
    Sub --> Tools
    Team --> Tools
    Skills -.->|Methods| Tools

    Tools --> Web["Browser / MITM proxy<br/>Tabs / flows / paused requests<br/>Breakpoints, replay and HAR"]
    Tools --> Analysis["Scans / reverse engineering<br/>Task / ReverseJob<br/>Samples, derived artifacts, analysis"]
    Tools --> Execution["Sandbox / hosts / desktop<br/>Shell sessions / files / environments<br/>Scripts, SSH and devices"]
    Tools --> Knowledge["Knowledge / evidence / reports<br/>Cases, artifacts and evidence"]
    Tools --> Recall["Long-term and cross-session memory<br/>Search → session / message locators<br/>Paged history and archived references"]
    Tools -.-> Extensions["Optional tools and integrations<br/>MCP / external scanners<br/>Ghidra / Frida / JADX"]
    Web --> Review["Main Agent reviews<br/>State / steps / evidence"]
    Analysis --> Review
    Execution --> Review
    Knowledge --> Review
    Recall -->|Verify earlier work and related tasks| Review
    Extensions -.-> Review
    Review --> Delivery["Reports / PoCs<br/>Summaries and session sandbox files"]
    Delivery -.->|Remote delivery as agreed in the task| Outbox["Paired identity → Outbox<br/>Adapter sends<br/>Delivery status checks"]
    Review -->|Update plan / continue / retest| Main
    Sub -.->|Completion notice / eligible parent wake| Main
    Team -->|Queue public messages / respond or pass| Team
    Team -.->|Read chat and artifacts| Review

Domain tools and Skills are discovered and used as needed. The session sandbox provides files and a script environment; browser, proxy and scan services, and external Agents, use their own execution environments. See execution loops and wakeups for control flow, and architecture and development for module entry points.

Runtime design

Conversation history, execution state, streaming events and domain artifacts are managed separately, connected by run identities and material references. Long tasks and multi-Agent work use these mechanisms:

See Agent runtime and data flow for threads, event streams, storage, key functions and design boundaries.

The Agent works continuously with stateful tools. It can keep operating on the same browser tab, inspect existing proxy flows and paused requests, send further commands to an interactive shell, or continue a ReverseJob from its samples, analysis and derived artifacts. Todos track steps, tasks and jobs expose state, and evidence references connect stage outputs. The Agent uses this information to choose its next action. Live connections, running processes and durable records have separate lifecycles; continuing work starts with checking state and deciding whether to reuse a resource or recreate its environment. See stateful tools and continued operation for examples.

Retrieve earlier work when it matters. The Agent forms search queries, refines them when needed, locates previous sessions, messages and task references, then reads original text and evidence and checks the related task's current state before continuing. Searchable long-term records can extend far beyond a single model request's context window; only relevant material is brought into the current turn. Search covers saved sessions in the current local data environment; queries from ordinary incoming channel messages are also limited by the paired identity's accessible sessions. See cross-session memory and task handoffs for usage examples.

Use model endpoints or a local Agent. Configure AI endpoints directly, or connect locally installed and signed-in Agents such as Codex, Cursor and Claude Code through ACP. They can work inside ArgusAI and call workbench capabilities through its tool bridge. An ACP main conversation does not require a separate native ArgusAI model endpoint; native subagents, team members and other AI analysis tasks use their own runtime and model configuration.

Continue work on PCs and servers from your phone. Pair QQ, Feishu, Telegram or another supported channel to send tasks, check progress and receive reports and files from a phone, tablet or another computer. The Agent uses SSH, MCP or other connections configured on its work host to operate reachable computers and servers. Desktop control acts on the desktop hosting the tool, and results can return to the paired channel. See integrations and messaging.

For delivery after completion, include “Send the summary and report files back to this paired channel, then verify delivery” in the task's acceptance criteria. Ordinary channel replies can use channel_reply for the exact inbound identity; proactive messages use channel_send_message, and files use channel_send_file, subject to routing and tool confirmation policy. Queue acceptance means delivery was requested; sent means the send interface succeeded, not that the recipient read it. A scheduled task's report_to_origin reports to the application conversation that created it; agree separately on channel recipients and artifacts for QQ or other platforms.

In action

Desktop Agent

CLI

One workspace for analysis and execution

Describe a goal in the full conversation or through the floating entry, such as “Continue the current application audit, refine the plan, advance the analysis within scope, and preserve evidence.” The Agent organizes tool execution around the task. Open feature pages to inspect progress and results; when more material is needed, drag a sandbox file onto the floating button to reference it in the conversation and continue.

Built-in checks, skill-guided workflows and external integrations handle different parts of the process. The Wiki manual describes their inputs, dependencies and usage. The Wiki's primary documentation is in Chinese; this page provides the English project overview and quick start.

Continuing execution and proactive discovery

Autonomous turns spanning tens of hours

ArgusAI supports autonomous execution on the scale of tens of hours within a single Agent turn. A turn is one user task containing repeated model and tool calls, not one HTTP or model request. The runtime has no fixed model/tool round-count ceiling. Its default emergency wall-clock limit is 7 days, with progress checks, loop detection, cancellation and deadline handling retained.

This is a runtime configuration and control-flow capability. Actual duration depends on the task, model quota, tools, resources and authorization. Long investigations, sample batches and multi-stage validation can progress within one turn; durable tasks and the scheduler carry work across turns or resume it on a later event.

The native runtime keeps a stable core control surface and discovers domain tools through the catalog. Before model requests it manages history against the context budget; large results can use summaries and artifact references. When earlier work is needed, the Agent searches memory and reads relevant sessions, tasks and artifacts before returning to the current loop. The sequence below connects recall, turn continuation, parent wakeups and background status queries. ACP conversations use the selected external Agent's reasoning loop.

sequenceDiagram
    participant U as User / session entry
    participant A as Main Agent runtime
    participant M as Model
    participant T as Tools / subagents
    participant S as State and artifacts
    U->>A: Goal, materials or continuation request
    loop Work remains actionable and runtime conditions allow
        A->>M: Stable core tools / budgeted context
        M-->>A: Next call, delegation or wait
        alt Invoke workbench capabilities
            A->>T: Discover tools, read Skills, create or select a work object
            T-->>A: Object ID / current state / existing materials
            A->>T: Choose next action from state, confirm and act on the same object
            T-->>A: Updated state / results / evidence references / job receipt
        else Recall earlier work
            A->>T: search_memory / search_all_memory
            T-->>A: Session and message locators, task and artifact references
            A->>T: Read history pages, verify tasks and archives by ID
            T-->>A: Relevant original text and evidence references
        else Short wait in the current turn
            A->>A: wait_for_duration, returns when due, cancellable
        else Wait for subagents
            A->>T: wait_for_agents
            T-->>A: Status after completion, timeout or user interjection
        else Query a background job
            A->>T: background_job_status(job_ref)
            T-->>A: Current status or results, wait and query as needed
        end
        A->>S: Update Todo / checkpoints, save needed artifacts
        S-->>A: Summaries, references and next-step context
    end
    opt Subtasks end, parent is idle and eligible to continue
        T-->>A: Batched agent_completion notice wakes the parent
        A->>M: Read results, continue review and reporting
    end
    A-->>U: Deliver / wait for input / explain why the turn stopped

A user interjection can end wait_for_agents while workers continue; wait_for_duration is a cancellable short wait. Ordinary background jobs are queried by job_ref, while persistent teams coordinate through chat and member queues. The scheduled tasks below can also supervise that work.

Cross-turn continuation and events

The Agent stores progress in todos, checkpoints, knowledge and artifacts. The scheduler reconnects that work on the next trigger.

flowchart TB
    Register["Configured persistent task"] --> T
    T["Interval / Cron<br/>Signed Webhook / file changes"] --> Scheduler["Scheduler<br/>Host lease / execution lock"]
    Scheduler --> Ready{"Session available?"}
    Ready -->|Busy| Busy["Defer and check again<br/>May skip after the deferral window"]
    Busy --> Waiting["Wait for a later check, time or event"]
    Ready -->|Available| Destination["Execution destination"]
    Destination --> Existing["session<br/>Wake a specified conversation"]
    Destination --> Dedicated["dedicated_session<br/>Create once, then reuse"]
    Destination --> New["new_session<br/>A separate conversation each run"]
    Existing --> Context["Read the task context, Todo,<br/>checkpoints, knowledge and artifact references"]
    Dedicated --> Context
    New --> Context
    Context --> Run["Execute the next stage<br/>Patrol / analyze / validate<br/>Check team or background work"]
    Run --> Save["Save progress and artifacts<br/>Compare baselines / update checkpoints"]
    Save --> Notify["Notify by policy<br/>Optionally report to the origin conversation"]
    Notify --> Enabled{"Enabled and eligible?"}
    Enabled -->|Continue| Waiting
    Waiting --> T
    Enabled -->|Disabled / run limit reached| Stop["Stop future triggers<br/>Keep records and artifacts"]
    Scheduler -->|Disabled / run limit reached| Stop

New conversations carry work through explicit task context, knowledge and artifacts; existing and job-owned conversations retain their own history. Finishing one run can leave the schedule waiting for its next trigger. The Agent disables it as agreed when the objective is met, or it stops through user action or its run limit. The scheduling host must remain running, and each scheduled execution has its own deadline.

Choose the execution destination independently of the trigger:

Long tasks can use max_runs=0 to run without a fixed execution-count limit. Each turn reads checkpoints, performs the next step and saves state. This durable, segmented continuation, together with context compaction and evidence archives, supports long investigations, recurring patrols and multi-stage work. The scheduler, models and tools must remain available; information, resources and authorization still determine whether each turn can proceed.

The automation manual covers triggers, destinations, run counts and notification policies.

Enterprise workflows

Alerts and remote state come from materials supplied by the user or configured tools, with checks and validation organized within the authorized scope. The responsible team reviews vulnerability conclusions, risk acceptance, production changes and incident response decisions. See enterprise workflows for inputs, review points and deliverable organization.

Quick start

Two editions: Desktop includes the GUI and full CLI. Shell provides command-line access for servers and SSH sessions, retaining Agent, channel, task, proxy and reverse-analysis capabilities. Shell archives contain shell in their names and do not require desktop WebView components; external runtimes such as browsers are still needed for the features that use them. See Releases for stable and preview packages, and installation for instructions.

The current version is 0.1.12. Download the prebuilt package for your platform and its .sha256 from Releases, then follow installation to verify and install it. The terminal examples use an argusai command entry. Without one, use .\ArgusAI.exe from the Windows installation directory or ./ArgusAI from the extracted Linux directory; see the CLI reference for the macOS entry.

argusai version --json
argusai --gui
argusai chat

On first launch, choose a data directory and configure native AI endpoints and models, or select a locally installed, signed-in and tested ACP Agent. Check browser and external tool paths as needed. Open the full Agent conversation or floating entry and give the Agent the goal, materials and constraints so it can plan and start work. For a first task, provide an approved HAR or JS file and ask the Agent to inventory interfaces, identify leads and archive evidence, then inspect the results on the relevant feature pages.

Windows needs WebView2 Runtime; Windows ARM64 also needs the native Microsoft .NET Desktop Runtime. macOS desktop automation requires system permissions. Linux needs GTK and WebKitGTK desktop libraries. External models, scanners, reverse CLIs and devices are prepared for the features you use; see installation.

uv sync --locked
npm --prefix argusai/webui ci
npm --prefix argusai/webui run build
uv run argusai --gui

uv run --locked --group build python build.py --help
uv run --locked --group build python build.py --dry-run
uv run --locked --group build python build.py --jobs 2

Documentation map

The linked Wiki pages below are primarily in Chinese.

Data and scope of use

Sessions, tasks, knowledge, reverse artifacts and logs are stored under the configured data directory. AI requests go to user-configured services; search, downloads, messaging and out-of-band verification may also contact external services. Session file and runtime separation organizes execution; actual access remains subject to tool authorization and host permissions.

Use ArgusAI on systems you own, explicitly authorized assessments and isolated labs. Establish authorization for targets, methods, time windows and impact. Review model conclusions and assess active scans, traffic rewrites, dynamic instrumentation and production schedules. See data and scope of use.

License

Except for third-party content with separate notices, ArgusAI is licensed under GNU GPL version 3 only (GPL-3.0-only). Later versions are not automatically permitted. Individuals and businesses may use, modify and commercially use it under this license; business use does not require a separate software license purchase.

When distributing the program or a combined work covered by the GPL, provide the Corresponding Source, preserve copyright and license notices, and meet the other applicable GPLv3 conditions. See LICENSE for the complete terms.

Bundled third-party components retain their own licenses; see THIRD_PARTY_NOTICES.md for their scope and notices. DAWA Technology may provide paid deployment, integration, customization and technical support services. These services do not change the rights granted by the GPL.

Participate

Contribute reproducible issues, tool adapters, checks, Skills or interface improvements. Include the version, operating system, reproduction steps and redacted logs. Preserve third-party tool and vendor license notices.

Contributions use the license applicable to the relevant files: GPL-3.0-only for project code and the original licenses for third-party content. Contributors retain their copyright.

Report an issue · Development rules · Architecture · Wiki maintenance

Open-sourced by DAWA Technology (达瓦科技) · HG-ha/Argusai