A CAMS-certified financial-crime professional — and the sixty-four-agent intelligence system he built to read markets, regulators, and blockchains around the clock.
A personal intelligence operation: sixty-four autonomous agents that wake on their own schedules, read primary sources, and file structured findings — designed from the outset so that every run compounds a permanent, queryable archive.
Each agent is a specialist with a beat: one pulls the U.S. sanctions list every morning at six and diffs it against yesterday's. One reads crypto markets every eight hours. One watches a single New Jersey town's housing market. Findings post to a shared workroom, persist to an append-only record, and distill into two daily briefings. The design premise is self-leverage — knowledge, tooling, and evaluated predictions accumulate in one system that every future run reads before it writes.
This is the actual schedule, shown against your clock — the gold marker is where the fleet is right now (Eastern Time). Every entry below is a real agent that ran today, or will.
Weekends run lighter — but Saturday brings the deep-research engine, and Sunday morning the evolution engine reviews the fleet's own performance and ships internal upgrades through an adversarial verification gate with automatic rollback. Outward-facing changes still wait for the operator.
Crypto prices, funding, sentiment, prediction markets, and the macro backdrop — read continuously and reconciled against a simulated portfolio that has to live with its own calls.
Legislation, enforcement actions, and agency guidance across digital-asset regulation — plus a sanctions-list diff every morning. The desk closest to the day job: every finding severity-ranked and archived.
Wallets, flows, and protocols watched directly on public blockchains — the tracing discipline of the day job, pointed at open data.
A research base of 36,000 logged wagers — profit, variance, and sizing diagnostics — feeding a daily scan for mispriced lines, sized by quarter-Kelly. Treated as research, run like research.
Breakthrough-physics claims, AI research, long-shot ideas — investigated seriously, steel-manned and counter-argued. Saturdays, a deep-research engine writes the long reports.
The system that runs the system: a watchdog that audits every agent, an auto-repair crew that fixes drift, and a weekly evolution engine that proposes its own upgrades — human-gated.
Prediction-market research desk — event contracts priced four times daily, every trade railed by a kill switch and a bankroll floor.
The agent that manages the agents — missed-run detection, data-source health, and autonomous budget throttling.
Twice-daily frontier-physics desk — propulsion claims, declassifications, and preprints, compounded into standing white papers.
The Treasury sanctions diff — list deltas pulled, compared, and delivered by 6:00 AM ET daily.
The Sunday self-improvement cycle — fleet performance reviewed, upgrades shipped through the adversarial gate.
Saturday long-form engine — multi-perspective research dossiers with citation discipline, in the STORM pattern.
No exotic infrastructure — a laptop, a message workspace, and a database. The sophistication is in the discipline: every agent follows the same production patterns, writes to the same archive, and answers to the same watchdog.
A watchdog patrols four times a day for missed runs and dead data sources. An auto-repair crew fixes configuration drift every eight hours. On Sundays, an evolution engine reviews fleet performance and ships upgrades through an adversarial verification gate — with automatic rollback if quality regresses.
The fleet lives on a ~800-run weekly budget. When the burn rate trends hot, the watchdog throttles autonomously — luxury agents pause first, high-frequency agents slow next, and a protected core of seven keeps running no matter what.
Dashboards show the present; the archive keeps the past. Every agent writes each run to an append-only database — so "what did the system believe on March 3rd?" is a query, not a guess. Predictions are logged before outcomes, where they can't be quietly revised.
Systems earn adjectives through measurement. Every figure below is drawn from the operation's own records — the append-only archive, the generated registry, and the git history — as of July 8, 2026.
The fleet is run the way regulated systems are run: named controls, each observable, each with a cadence.
| Control | Function | Cadence |
|---|---|---|
| cortex-watchdog | Fleet-wide health patrol — missed runs, dead data sources, budget burn | 4× daily |
| fleet-auto-repair | Configuration-drift scan and autonomous correction across every agent spec | 3× daily |
| jit-budget-governor | Four-tier autonomous throttling against a ~800-run weekly budget — luxury agents pause first, a protected core never does | continuous |
| deadman-liveness | Silent-failure detection — a schedule that stops firing is surfaced, not discovered | per schedule |
| eval-harness | Measured output-quality scoring, independent of agent self-rating | per run |
| append-only-archive | Every run, finding, and prediction written to SQLite — history is a query, not a recollection | per run |
| state-authority | Local state files are the single source of truth; display surfaces are projections, never masters | doctrine |
| idempotency-outbox | External sends guarded against duplicates — an unconfirmed send is verified, never re-fired | per send |
| verify-and-apply | Self-modifications pass an adversarial multi-reviewer verification gate with automatic rollback; outward-facing and scheduler changes remain human-gated | weekly cycle |
| fleet-backup | Full archive to cloud storage, restore runbook maintained | daily |
A modeled replacement estimate — what this footprint would cost to commission, stated so it can be checked.
| Artifact class | Count | Modeled hours |
|---|---|---|
| Agent specifications, kernel-integrated | 69 | 210 |
| Interactive terminals & dashboards | 16 | 380 |
| Data layer, kernel & observability | 1 | 120 |
| Skill-library documents | 86 | 130 |
| Registry, console & fleet tooling | — | 60 |
| Modeled build effort | ≈900 h |
Modeled effort of 700–1,100 hours at prevailing senior automation-engineering contract rates ($110–$175/hr), rounded conservatively. Actual cost: one person, thirteen weeks of nights and weekends, on consumer hardware — the gap between those two numbers is the argument for AI-assisted engineering.
METHOD — artifact inventory × conservative per-class build-hour estimates; rate band from prevailing U.S. senior contract automation rates. A model, not an audited figure. Counts drawn July 8, 2026 from the system's generated registry, append-only archive, and git history.
The architecture didn't stay private. The fleet's production patterns are generalized — no employer data, nothing proprietary — and published as two complementary repositories: the runtime for building agent fleets, and the content to feed any AI assistant.
A production-grade framework for building, scheduling, and operating autonomous agent fleets — this system's architecture, generalized. An agent kernel with local-state authority, an idempotency outbox, human-gated self-modification, deadman liveness, and JIT budget management — scheduled with GitHub Actions, tested in CI, demonstrated live on GitHub Pages.
The content half: a copy/paste library of analytical prompt and output templates for work at financial institutions — financial-crime compliance, controls and independent testing, fraud, surveillance, regulatory, research, and market analysis. Every feature replicates with at most two files, a rule enforced in CI — plus a pure-Python quant library.
The generalization step is the point. Everything published is stripped to its portable core — no personal data, no proprietary context, nothing that couldn't sit in a public library. That makes the repositories function as OSINT-grade reference material: public, citable, and usable inside any institution's rules — by the author and by anyone else. The private fleet dogfoods every pattern first; what survives production becomes the public reference.
Max Moran
github.com/maxmoran23 · three public repositories · pinned work · whatever ships next
The fleet is the centerpiece, but the shelf runs deeper — a sixteen-entry port map of terminals and dashboards on local hardware. Live captures first, then the shelf itself.
Three of the terminals — Signal Forge, Apple Music Intelligence, and Career Intelligence — are packaged as standalone SwiftUI applications for iPhone and iPad, streaming from the home lab over a private mesh network and built under an Apple Developer Program membership. Push notifications and TestFlight distribution are staged next.
None of this was hand-written code in the traditional sense — and that is the finding. The system was engineered through specification, orchestration, and adversarial verification: plain-language operating law, independently reviewed changes, measured rollback.
Behind it sit three years of top-percentile large-language-model practice — a heavy user since the first public releases, among the heaviest individual users of frontier assistants by 2025, and operating them daily at production intensity since. The craft is systems doctrine: recognizing which patterns hold under failure, writing them down, and making every future build inherit them. Four of those doctrines, and why they carry weight:
Every run reads the accumulated archive — findings, tooling, evaluated predictions — before it writes to it. New agents inherit the full library on day one.
Why it mattersUsage becomes infrastructure. The system gets cheaper to extend the longer it runs — the opposite of most automation, which decays.
Local state files are the single source of truth; every display surface is a disposable projection. No component ever trusts a dashboard over the record.
Why it mattersEliminates an entire failure class — silent divergence between what a system shows and what it knows — rather than detecting it after the fact.
Self-modifications ship only after adversarial review attempts to break them, with automatic rollback if quality regresses. Findings must survive attack, not just sound plausible.
Why it mattersAutonomy without trust-by-default — the same standard this site was held to before publishing.
The fleet lives on a ~800-run weekly budget and throttles itself under pressure — luxury agents pause first, a protected core never does.
Why it mattersEconomics as a first-class control, designed in from the outset — not bolted on after the first overrun.
Financial-crime work that has to survive a regulator's read — tracing funds across blockchains, weighing vendor claims, writing analysis to an institutional standard.
Max Moran is a CAMS-certified compliance professional with five years across exchange, institutional, and global-bank settings, focused on digital assets, sanctions, and blockchain investigations. He began in blockchain forensics at Coinbase — de-mixing transactions, tracing darknet exposure — helped build a digital-asset compliance function at Cantor Fitzgerald, and now serves as Director of Digital Assets Advisory within Global Financial Crimes at Morgan Stanley.
The systems work started earlier than the fleet. Three-plus years of daily practice with large language models — from the first public releases, through hundreds of millions of tokens of real-world prompting — first surfaced at the Cantor Fitzgerald compliance desk as hand-built prompt libraries for OSINT research and due-diligence drafting, before native AI tooling existed. At the end of 2025 the practice found its instrument in Claude Code. The first interactive terminals shipped by March; by April the fleet's first commit already contained thirty-eight scheduled agents and the full Slack-first architecture. Seven months of daily, production-intensity engineering followed — not a course of study, but an operation that had to keep running.
The curriculum was written by failures. A display-platform character cap silently broke state persistence across the fleet — the answer became the state-authority doctrine: local files are truth, displays are projections. A digest email delivered three times because a retry fired before its acknowledgment surfaced — the answer became the idempotency outbox, and "never re-fire an unconfirmed send" became kernel law. Prose inventories drifted from reality — the answer was a generated registry that distrusts prose entirely. Every incident ended the same way: as a named, versioned pattern that every future agent inherits on day one.
The distinguishing habit is institutional: the system is treated the way a bank treats a process. In June, a thirty-five-agent adversarial audit was commissioned against the architecture itself; it returned an unflattering maturity score and a blunt verdict — and the remediation shipped within days: a versioned kernel, out-of-band liveness monitoring, measured evaluation. The same skepticism shapes the analytics — self-assessments engineered to resist their own bias, evidence metrics that score what should exist against what survives, mandatory counter-arguments on exactly the claims most likely to be believed. Compliance instincts, transferred whole into systems engineering.
All of it began as a working question: compliance is pattern recognition at scale — what does one analyst with real infrastructure look like? Everything on this page was built outside working hours, on personal hardware, from public data, and it compounds weekly by design.
The progressionNew York · Financial crime, digital assets & applied AI