Autonomous security operationsRead-only scope · human-verified findings

Autonomous AI Security Auditing & Threat Triage at Scale

Combining high-reasoning LLMs with human security research to continuously inspect smart contracts, detect zero-day web flaws, and auto-generate patch PRs.

Launch Interactive Scanner Book Security Consultation

fix(reentrancy): apply CEI ordering in withdrawopened 42s after detection by Namada Bot

auto-patch

contracts/Vault.sol

diff --git a/contracts/Vault.sol b/contracts/Vault.sol
@@ -41,9 +41,11 @@ contract Vault {
-    function withdraw(uint256 amount) external {
+    function withdraw(uint256 amount) external nonReentrant {
         require(balances[msg.sender] >= amount, "insufficient");
-        (bool ok, ) = msg.sender.call{value: amount}("");
-        balances[msg.sender] -= amount;
+        balances[msg.sender] -= amount;   // CEI: state first
+        (bool ok, ) = msg.sender.call{value: amount}("");
         require(ok, "transfer failed");
     }

regression test passinggate armed for future commitsview in dashboard

30
Rule classes: 18
Posture checks: v3.1
CVSS version: 0 B
Source retained

Claude Mythos 5.1 / Fable 5.1 adversarial review
30 rule classes across Solidity, Vyper and Rust/Anchor
No source retained after the response

Mapped toSWC RegistryCWE Top 25OWASP Top 10OWASP API Top 10CVSS v3.1MITRE ATT&CKNIST SSDFERC-4626Anchor 0.30

Run the engine before you talk to us

Three engines, two live

Three tools, all live on this page. Two of them are genuinely analytical — a deterministic contract rule pack and a real CVSS v3.1 triage engine. The third is a labelled simulation, and it says so.

2,247 / 60,000

Source under audit

// SPDX-License-Identifier: MIT
pragma solidity ^0.7.6;

interface IERC20 {
    function transfer(address to, uint256 amount) external returns (bool);
    function approve(address spender, uint256 amount) external returns (bool);
}

contract LegacyVault {
    address public owner;
    uint256 public totalSupply;
    uint256 public feeBps;

mapping(address => uint256) public balances;
    address[] public depositors;

event Deposit(address indexed user, uint256 amount);

// No initializer guard: reachable by anyone after deployment.
    function initialize(address _owner) public {
        owner = _owner;
        feeBps = 50;
    }

function deposit() public payable {
        balances[msg.sender] += msg.value;
        totalSupply += msg.value;
        depositors.push(msg.sender);
        emit Deposit(msg.sender, msg.value);
    }

// The external call lands before the balance is cleared.
    function withdraw(uint256 amount) public {
        require(balances[msg.sender] >= amount, "insufficient balance");
        (bool ok, ) = msg.sender.call{value: amount}("");
        balances[msg.sender] -= amount;
        totalSupply -= amount;
    }

// Privileged reassignment with no authorisation.
    function setOwner(address newOwner) public {
        owner = newOwner;
    }

function emergencyDrain(address payable to) public {
        require(tx.origin == owner, "not owner");
        to.transfer(address(this).balance);
    }

// Fee derived from block fields, so it is predictable and grindable.
    function luckyFee() public view returns (uint256) {
        uint256 roll = uint256(keccak256(abi.encodePacked(block.timestamp, block.difficulty, msg.sender)));
        return roll % 100;
    }

// Unbounded loop over an array that only ever grows.
    function refundAll() public {
        for (uint256 i = 0; i < depositors.length; i++) {
            address payable user = payable(depositors[i]);
            user.transfer(balances[user]);
        }
    }

function payout(IERC20 token, address to, uint256 amount) public {
        token.transfer(to, amount);
    }

function approveMax(IERC20 token, address spender) public {
        token.approve(spender, type(uint256).max);
    }
}

Pre-0.8 vault with reentrancy, an open initializer and an unprotected owner setter

The rule pack runs on the server and the source is discarded with the response — nothing you paste here is stored or used for training.

No audit run yet

Pick a sample or paste your own contract, then run the audit. The detector pack covers reentrancy, access control, oracle manipulation, unchecked calls, arithmetic and 30+ more rule classes across EVM and SVM.

Raw bug report1590 chars

# Unauthenticated SQL injection in the reporting filter endpoint

**Asset:** https://reports.acme-corp.com/api/v2/filter
**Severity:** Critical
**CVSS:** CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:N

## Summary
The `sort` query parameter is concatenated directly into the SQL statement
without parameterisation. An unauthenticated attacker can inject arbitrary SQL
and read every row in the reporting database, including the `customers` table.

## Steps to reproduce
1. Send a GET request to `/api/v2/filter?sort=created_at` and note the 200 response.
2. Replace the sort value with `created_at;SELECT+1` and confirm the response time changes.
3. Inject a UNION SELECT to append the `customers` table to the result set.
4. Observe that no authentication cookie or API key is required for any of the above.

## Proof of concept
```http
GET /api/v2/filter?sort=created_at%20UNION%20SELECT%20email,password_hash,1,1%20FROM%20customers-- HTTP/1.1
Host: reports.acme-corp.com
```

The response body contains the full customer table, roughly 240,000 records,
including bcrypt password hashes and billing addresses.

## Impact
An unauthenticated attacker can exfiltrate the entire customer database. The
recovered password hashes enable offline cracking and, because the same
credentials are reused on the main application, full account takeover at scale.
This is a pre-authentication compromise of confidentiality and integrity across
the whole tenant.

## Remediation
Use parameterised queries or an ORM for the sort clause, and validate the sort
key against a static allow-list of column names.

Markdown, plain text or a raw email paste. An explicit CVSS vector in the report is honoured rather than inferred.

Reports are matched against a local submission corpus in the same request. Nothing is written to a queue and the report text is not retained.

Nothing triaged yet

Paste an inbound report and triage it. You get a real CVSS v3.1 base score, extracted reproduction steps, a duplicate-risk verdict against prior submissions, and a completeness score with the gaps named.

Four ways we get between you and a breach

four disciplines

Manual review paired with symbolic execution and fuzzing, across the bug classes that drain contracts and APIs. Every engagement is scoped in writing and priced before it starts.

EVM, SVM and Vyper
Smart Contract Audits
- Solidity
- Vyper
- Rust / Anchor
- Foundry
- Halmos
OWASP Top 10 and beyond
Web App & API Penetration Testing
- OWASP Top 10
- OAuth 2.0 / OIDC
- GraphQL
- REST
- WordPress
Cut duplicate noise by 80%
Automated Bug Bounty & VDP Triage
- HackerOne
- Bugcrowd
- Intigriti
- Immunefi
- Jira
Next.js and cloud architecture
Secure Full-Stack Web Development
- Next.js
- TypeScript
- PostgreSQL
- Terraform
- AWS / Vercel

All four disciplines

Active where you already submit

six platforms

The programmes most of our clients already run, which means we have read the reports their triage queue is drowning in — and written a few of them.

HackerOneWeb, API and mobile programmes
HackenProofWeb3 VDPs and audit contests
ImmunefiSmart contract bounties, EVM and SVM
BugcrowdCloud and enterprise estates
IntigritiEuropean VDP and pentest programmes
Code4renaCompetitive Solidity review

See every platform

From webhook to patch pull request

six stages

A signed webhook starts a run. Sources are parsed into an AST and an inter-procedural call graph before any rule fires, so taint can be traced across function boundaries rather than guessed at from a single file.

Inter-procedural taint traceoutput of stage 02

A rule that only reads one function body sees _settle() and nothing that taints it. The path above crosses two frames before it reaches the state write, which is why the graph is reconstructed before any rule runs.

Repository webhookHMAC-signed · <200ms
AST & call-graph buildSolidity · Rust · TS
Symbolic & fuzz executionHalmos · Echidna · Trident
Reasoning ensembleMythos / Fable → Opus
Human verificationNo unreproduced findings
Patch PR & regression gateAuto-PR · CI enforced

How a scan runs

One model argues, another has to agree

four models

A single model asked whether code is exploitable will usually find a reason to say yes. So the first pass is asked to prove each candidate wrong, and only what survives it is passed to the pass that writes the fix.

Anthropic

Claude Mythos 5.1

Adversarial refutation

Where the deployment is admitted to the Cyber Verification Program · /api/review

Anthropic

Claude Fable 5.1

Adversarial refutation, general release

The default for this pass · /api/review

Anthropic

Claude Opus 5.5

Patch synthesis

Survivors only · emits the proposed diff

Anthropic

Claude Sonnet 5.5

Triage judgement

Every triaged report · /api/triage/notes

Inside the ensemble

Priced before the work starts

three shapes of engagement

No discovery-call funnel, no day-rate surprises. Pick the shape of engagement that matches how often you ship, and the deliverables are listed against it before you sign.

On-Demand Audit

$12,000per engagement

For protocol launches and pre-mainnet gate reviews.

Enterprise ContinuousMost adopted

$4,800per month

For teams shipping to production every week.

Agency Retainer

Customannual agreement

For consultancies white-labelling our analysis.

Compare the tiers

Built to be audited itself

six controls

The same discipline we ask of your code applies to how we handle yours: read-only scope, no source retained after the response, and a finding that cannot be reproduced is never billed as one.

Findings are labelledcriticalhighverifiedmodel-authored

Continuous posture tracking
Least-privilege by default
Edge-native delivery
Audit-ready evidence
Cloud and on-prem targets
Scoped and authorised

How we handle your code

The things people ask before signing

eight questions

It depends on the tab, and we label which is which. The smart contract auditor runs a real, deterministic rule pack over the code you paste: it is posted to /api/audit, scored on the server, and the source is discarded with the response — nothing is stored and nothing is used for training. The web scanner is a simulation that derives a report from the target name and sends no traffic to it; live scanning requires a signed authorisation. The triage engine is real: it parses your report, computes a genuine CVSS v3.1 base score, and runs similarity matching against a submission corpus.

Book a consultation

Bring us the thing you are most worried about

Tell us what you are shipping and when. You will get a written scope, a fixed price and a named researcher before any contract is signed — not a discovery call that ends in a proposal template.

First response within one business day, always from an engineer.
Read-only scope. We never request production write access.
Mutual NDA available before you share a single line of code.

security@namada.site

Autonomous AI Security Auditing & Threat Triage at Scale

Run the engine before you talk to us

Four ways we get between you and a breach

Smart Contract Audits

Web App & API Penetration Testing

Automated Bug Bounty & VDP Triage

Secure Full-Stack Web Development

Active where you already submit

From webhook to patch pull request

One model argues, another has to agree

Claude Mythos 5.1

Claude Fable 5.1

Claude Opus 5.5

Claude Sonnet 5.5

Priced before the work starts

Built to be audited itself

The things people ask before signing

01Is the sandbox on this page running a real scan?+

02Which models do you use, and what do they actually do?+

03What happens if the model is unavailable, or you have no API key set?+

04How is this different from running Slither or a linter?+

05What do you need access to?+

06How fast is a typical engagement?+

07Do you cover Rust and Anchor, or only Solidity?+

08What happens after a finding is fixed?+

Bring us the thing you are most worried about