Skip to content
Argus
Start free

Argus

Your AI agents write code. Who makes sure they follow your architecture?

Make AI-driven development architecture-safe.

Coding agents speed up development. They also bring drift, broken boundaries and changes nobody approved. Argus connects the architecture you approved to the way your team works: it detects violations, checks your engineering rules and tracks every change, by developers and by agents.

  • Architecture checks
  • Agent accountability
  • Continuous verification
Start freeSee how it works

Sign in with GitHub. Your account is created on first sign-in.

Your architecture is documented. But is it actually being followed?

  • Architecture drift

    An undeclared import here, a component the model never heard of there. Each is small; together they turn the approved architecture into a document nobody can trust.

  • Uncontrolled agent activity

    Coding agents change many files fast, without seeing which dependencies your architecture allows. A pull request alone doesn't say which agent made it, or what it claims to have checked.

  • Late detection

    A broken boundary is often found weeks later, in a review or an incident. By then other code depends on it, and the fix is a refactor.

From architecture decisions to enforceable engineering rules

  1. Define your architecture

    Components, layers, source paths, owners and allowed dependencies, as a model in Git beside your architecture decision records.

  2. Turn decisions into rules

    Each rule has an ID, a severity and the decision it comes from. The model generates the import contracts the check enforces.

    Enforcement modes per rule Coming soon

  3. Monitor development activity

    The check runs in your own CI on every pull request and on main. Each pull request is attributed to a person or an agent, and agents report their sessions.

  4. Verify and enforce

    Every finding names its rule, component, file and line. Breaking contract changes are flagged on the pull request. Agents ask the model before they code.

    A required check that blocks a merge Coming soon

  5. Keep traceable evidence

    Findings keep their history, approvals from GitHub reviews and labels are recorded, and changes go into an append-only audit log.

    Approved baseline revisions and evidence records Coming soon

Everything needed to keep engineering aligned

  • Architecture model

    Components, layers, owners, source paths and contracts as code, drawn live with each component coloured by its latest status. For any component, see what a change to it reaches.

    Domains and cross-team ownership Coming soon

  • Rules and checks

    A rule catalogue with IDs, severities and the decisions behind them. Checks on every pull request and on main, with findings over time, and breaking-change findings for OpenAPI contracts and MCP tool lists.

    Enforcement modes and a required pull request check Coming soon

  • Agent activity tracking

    Pull requests attributed to the agent that made them. The plan, tests and verifications an agent reports, labelled self-reported, beside the pull request's own check.

    Stopping a prohibited edit before it's written Later

  • Continuous drift detection

    A daily check on main, and rules evaluated after every refresh. Each finding keeps its ID and history, and metrics show how much is caught before merge and how fast it's fixed.

  • Governance

    Approvals recorded from GitHub reviews and decision labels: who approved what, and when, and whether the approver owns the code in CODEOWNERS.

    Approval-required rules and exceptions Coming soon

  • Engineering audit trail

    An append-only audit log of who changed what, when and from where, in a hash chain that can be verified. It is never pruned or edited.

    Evidence records Coming soon

Don't just see architectural violations. Prevent them.

Most tools tell you what happened. Argus checks what is allowed to happen, against the architecture you approved, where the code changes.

How Argus responds to each development event, and when
Development eventResponseStatus
A PR adds an undeclared dependencyA finding on the PR, with its rule and evidenceToday
A PR breaks a contractA breaking-change finding naming the consumersToday
An agent plans a changeMCP says whether the model allows it, before codingToday
A PR violates a block ruleA required check failsComing soon
A PR changes a protected contractApproval requiredComing soon
The architecture itself changesA new approved baseline revisionComing soon
An exception is grantedOwner, reason and expiry recordedComing soon
An agent attempts a prohibited editStopped before it's writtenLater

Built for human and AI engineering teams

One architecture. Every contributor accountable.

  • Developers

    See the components a change reaches, and the findings it causes, while it is still a pull request.

  • AI agents

    Ask the architecture before coding: whether a planned import is allowed, and which rule and decision apply. Then report their plan and results with their own token.

  • Engineering leads

    See what is drifting, which rules break most, how much is caught before merge, and how agents' pull requests fare against the check.

  • Architects

    Keep the model, rules and decisions in one place, and see where the code and the model disagree.

  • Platform teams

    Run the check in your own CI across repositories, and see which repositories report and how many of their components.

Works with your existing engineering workflow

Available Today

  • GitHub

    Sign-in, pull requests, reviews, labels and CODEOWNERS, through a GitHub App.

  • GitHub Actions

    The check runs in your workflow and keeps its results for the dashboard.

  • Claude Code, Codex and Cursor

    Through MCP: agents ask before coding and report what they did.

  • Slack

    A daily digest, and an alert for each new critical finding.

Next:

  • GitLabComing soon
  • Microsoft TeamsComing soon
  • OIDC single sign-onComing soon

Languages: Python today. JavaScript, TypeScript and Go next.

Security in brief

  • Sign in with GitHub

    Through a GitHub App with state and PKCE. Only a hash of your session ID is stored; sessions last seven days and can be revoked.

  • Organisation-scoped data

    Every read shows only the organisations you belong to. Membership is checked again every hour.

  • Secrets stay on the server

    Keys and webhooks are never returned by any screen or API. Agent tokens are shown once and stored hashed.

  • Audit log and approval records

    An append-only, hash-chained log of who approved, changed or authorised what.

Let your agents move fast. Keep your architecture intact.

Start on the free tier with a few repositories and agents. Sign in with GitHub; there is no separate sign-up.

Start freeSee pricing

Architecture-driven development for the age of AI coding agents.