Case study
Aether Codex
Agents that read code looking for trouble.
Reviewing an unfamiliar codebase is mostly a problem of attention. There is more surface than anyone can hold at once, and the bugs that matter tend to live where two assumptions meet rather than on any single line. Aether Codex is an attempt to make that work systematic — a director agent that delegates to specialists, each pointed at one kind of trouble.
The specialists
- recon_agent — maps architecture, trust assumptions and the boundaries between them before anything else runs.
- vuln_hunter — reads the Solidity directly, hunting exploitable bugs rather than lint findings.
- invariant_hunter — proposes invariants and fuzzes them, which is where multi-step and compositional bugs surface.
- poc_writer — builds Foundry proof-of-concepts that have to compile and pass, so a finding is demonstrated rather than asserted.
- rug_screener — screens an address for honeypot and rug mechanics.
- wallet_auditor — for smart accounts: Safe, multisig, ERC-4337.
How it is put together
Every agent is the same compiled LangGraph loop — agent → tools → agent → … → END — and sub-agents run inside the director's delegate calls, which makes the hierarchy real rather than a naming convention. The director can also spawn a specialist that did not exist when the run started, and search a persistent vector memory of what previous runs concluded.
┌──────────────────────┐
Gradio UI ──▶│ CODEX DIRECTOR │◀── CLI
└──────────┬───────────┘
delegate · delegate_many · spawn_agent · recall_memory
│
┌────────┬──────────┼──────────┬────────────┐
▼ ▼ ▼ ▼ ▼
recon vuln_ invariant_ poc_ (spawned at
_agent hunter hunter writer runtime…)
│
┌──────────┴───────────┐
│ ChromaDB vector store │
└──────────────────────┘What makes it more than a prompt
A library of 90 reusable invariants — conservation of assets, share supply accounting, withdrawal liquidity matching unclaimed requests — so a fuzzing run starts from properties that have caught bugs before rather than from a blank file. A fork lab with Foundry harnesses for testing against real chain state, and a proof-of-concept workspace where an exploit has to actually run.
The part that matters most is the insistence on demonstration. An agent that reports a finding is easy to build and mostly produces noise; one that has to write a test proving the bug is a different tool entirely, because a proof-of-concept that fails to compile is a finding that was never real.