Argus

Argus is accountability infrastructure for autonomous agents that act with real authority.

Autonomous agents are moving from chat interfaces into systems that can manage capital, execute workflows, and make delegated decisions. The problem is that most agent safety still depends on prompts, private logs, and trust in the operator. That is not enough when an agent can take actions with financial or operational consequences.

Argus turns every sensitive agent action into a verifiable workflow:

mandate → bond → ActionGate → verdict → trace → storage → slash → verify

A team defines a mandate with hard constraints: approved action types, maximum exposure, allowed targets, blocked recipients, and forbidden behavior. An agent registers with persistent identity and posts a bond. The agent cannot directly execute sensitive actions; it must propose them through the ActionGate.

If the action satisfies the mandate, Argus approves it, emits the verdict on-chain, stores the evidence trace, and commits the trace root. If the action violates policy, Argus rejects it, records the violation reason, slashes the bond, and reduces the agent’s compliance score.

Every decision creates a black-box trace containing the observation, reasoning summary, proposed action, policy checks, verdict, execution result, and penalty. The trace is canonicalized and hashed, so if the evidence is edited later, the root changes and tampering is detected.

Argus uses 0G Mainnet as the enforcement layer for mandates, agent registration, bonding, ActionGate verdicts, slashing, and trace commitments. It uses 0G Storage-style evidence URIs and replayable trace roots for the evidence layer. This creates a practical accountability system for AI agents: not just “the agent said it was safe,” but a verifiable record of what it tried to do, why it was accepted or rejected, and what penalty was applied.

During the hackathon, Argus was built from idea to a working deployed product.

Completed work includes:

1. Product architecture

- Defined the full accountability workflow: mandate, bonded agent, ActionGate, verdict, trace, storage, slash, and verify.

- Designed the product around real agent-risk scenarios rather than a generic AI wrapper.

2. Smart contracts on 0G Mainnet

- Built and deployed MandateRegistry for policy creation.

- Built and deployed AgentRegistry for persistent agent identity.

- Built and deployed AgentBonding for bonded stake and slashing.

- Built and deployed TraceCommitment for on-chain trace root commitments.

- Built and deployed ActionGate for approve/reject enforcement.

3. Verification and tests

- Added deterministic contract tests for mandate creation, agent registration, bond posting, compliant approval, policy violations, slashing, compliance score updates, trace commitments, and restricted permissions.

- Reached 27/27 passing Foundry tests.

4. Evidence and trace system

- Built canonical trace hashing.

- Created replayable proof packages.

- Added tamper detection so changed evidence produces a hash mismatch.

- Added proof views for trace roots, storage URIs, verdicts, and contract-linked evidence.

5. Agent simulation and demo flow

- Built deterministic agent-runner scenarios for compliant behavior and hostile instruction behavior.

- Generated demo traces for both accepted and rejected actions.

- Created a guided demo cockpit showing approval, rejection, slashing, and verification.

6. Frontend product

- Built a multi-page web application with dashboard, demo, agents, mandates, traces, violations, verification, proof receipts, developer docs, roadmap, and monitoring pages.

- Deployed the live app to useargus.xyz.

7. Documentation and submission assets

- Created a public GitHub repository.

- Added README and developer documentation.

- Recorded and uploaded the under-3-minute demo video.

- Prepared public project links and 0G deployment references.