I orchestrate AI agents within a framework built for institutions.

I design the governance, enforcement, and verification that make AI-built software safe to ship, and I write the standards and documentation that teams adopt. That range comes from years consulting on high-stakes programs for Virgin Voyages, the FIFA World Cup, and SiriusXM.

● New York City · open to AI program management, enablement & deployment roles

Selected work

AI Infra

GigaHarness

A fail-closed enforcement layer that makes AI coding agents trustworthy: it blocks any change it can’t verify, checks what the code actually does rather than how it reads, and logs every decision as a tamper-evident audit trail.

Creator

Framework

Atelier

My framework for building software to a standard that holds up under audit: a software factory where purpose-built agents turn a spec into shippable code. It’s the process behind everything below.

Creator

Automation

Unattended Operations

The automation layer that runs my operation after I log off: agents wired into Notion, Quire, and Gmail, overnight build runs, and controls that check every action before it executes.

Operator

Governance

Playbooks

The standing governance documents my agent teams operate under. They are loaded into agent context on every design pass and enforced by GigaHarness at build time.

Author

Quant Research

Research Platform

An instrument-agnostic research platform where asset, timeframe, and venue are all interchangeable. It can take a research idea in nearly any shape and prove it, and every result is fully reproducible.

Creator

Consulting

Standards

SiriusXM · FIFA · Virgin Voyages

Embedded advisor to enterprise programs: I find the operational gaps, then close them with the standards, handbooks, and onboarding documentation teams still train against years later.

Advisor

Production

Audio

Record labels & film

Produced commercial audio within teams, then led those teams. Production is where I learned the discipline I bring to software: a clear standard, relentless iteration, and a finished product that holds up.

Producer / Lead

← Index

AI Infra / Governance & enforcement

GigaHarness

A fail-closed enforcement layer that sits between an AI coding agent and your codebase. It checks every change against an explicit contract and refuses anything it can’t verify, so the work arrives with a tamper-evident audit trail and needs far less human review. Nothing about it is wired to one coding agent. It already runs on Claude Code and Codex, and the architecture is built to bring the next platform online fast.

63 locked proofs · 4/4 live acceptance runs · live on Claude Code & Codex

Built with the Atelier process →

What it does

01

Enforces a written contract

The contract is the same frozen design the build was approved from, turned into enforceable rules. The standard is written down once and stays identical from build to build.

02

Separation of authority

The contract defines truth, checkers only observe facts, and a neutral core makes the call. Nothing is allowed to certify itself.

03

Layered checks

It runs static rules, structural pattern checks, architecture (AST) checks, and live test execution against each change.

04

Fail-closed gating

A strict gate decides when work is clean enough to finish; a permissive mode lets active development keep moving without lowering the bar.

05

Tamper-evident audit trail

Every decision and piece of evidence is written as a content-addressed, hashed record, giving you the traceability auditors look for.

The result

AI-built software that’s fast to produce and proven before it ships, no matter which agent did the building. It’s trusted enough to govern the very agents that build it.

← Index

Automation / Event-driven operations

Unattended Operations

Automation only earns its keep when it’s safe to leave alone. My operation runs on that principle. Agents plug into the same systems a business already uses for project tracking, knowledge, and email, and they keep working after I log off. Every action gets checked before it executes and logged after.

MCP integrations across Notion, Quire & Gmail · overnight agent runs · pre-execution controls

Governed by GigaHarness →

How it runs

01

Wired into business systems

Agents work through the Model Context Protocol with direct access to Notion, Quire, and Gmail. A finding in one system becomes a task, a page, or an email in another with no human relaying it by hand.

02

The inbox as a routed pipeline

A routing layer reads inbound email, applies labels, and files what can wait. The messages that reach me are the ones that need a decision.

03

Documentation as a byproduct

Agents audit workflows and surface the gaps; I turn the findings into onboarding handbooks, SOPs, and reference guides. Enterprise teams have trained new hires against documentation built this way for years.

04

Overnight, unattended runs

Scheduled runs execute multi-stage work overnight. One agent builds, a second audits, and a gate decides whether the stage advances. By morning the work is either finished and verified or held with a reason attached.

05

Controls before execution

Enforcement hooks intercept each agent action and check it against policy before it executes. Anything that fails the check is blocked on the spot, and the decision goes into an audit log.

06

Human sign-off at fixed points

Certain calls stay with a person. Review gates sit at the specific points where judgment changes the outcome: approving a design, releasing a build, sending anything external. They are the same points a risk or compliance team would pick.

The result

The operation keeps moving when nobody is watching and can show its work afterward. Triage and status reporting handle themselves. My hours go to decisions, and the paper trail is already written when someone asks for it.

← Index

Quant Research / Systematic trading

Research Platform

An instrument-agnostic quantitative research platform: asset, timeframe, and venue are all hot-swappable, so the same engine researches whatever it’s pointed at. It pairs the flexibility to express an idea in nearly any shape with the machinery to prove it at a standard institutions trust.

How it’s built

01

Instrument-agnostic by design

Nothing is wired to a single market. Swap the asset, the timeframe, or the venue and the engine keeps working. The current deployment is just one reference configuration.

02

Many ways to express an idea

The platform speaks a rich, extensible language for research logic, so a complex, multi-part strategy becomes something the system tests directly instead of a throwaway script.

03

Search for edge

It explores the full space of parameters and variations to surface the candidates that show genuine signal, then proves them to an institutional bar.

04

Provable provenance

Every result is fully reproducible and backed by an immutable, verifiable record: the exact inputs, settings, and lineage behind it can be replayed and proven.

The result

Ideas of almost any shape go in. What comes out has been tested against a hard bar, and any result can be replayed from its immutable record.

← Index

Framework / System design

Atelier

My framework for building software to an institutional standard: a software factory where a bench of purpose-built agents turns a spec into shippable code. It’s the process behind GigaHarness and the research platform.

How it works

01

One agent, one job

Each agent is engineered around one specialized task. For days or weeks I iterate on a single output, feeding one agent’s result into the next, refining it, removing failure modes, and raising quality with each pass, until it becomes a reference I trust. Then I calibrate one agent with source files, instructions, and prompts until a single prompt reliably reproduces that standard.

02

Right-size every task

I measure how output quality shifts with task size, then give each agent the size of problem where it performs best: large enough to matter, small enough that quality never degrades.

03

Orchestrated over MCP

With the work right-sized, it’s coordinated through the Model Context Protocol, which organizes how context, tools, and agents move through a build.

04

Frozen into a contract

Before any code is written, the finished design is frozen, hashed, and turned into a contract. The contract and the design are one and the same: what gets approved is exactly what gets built and enforced, with no drift.

05

Mechanically enforced

GigaHarness sits between the agent and the codebase and refuses any change that breaks the contract, recording every decision as tamper-evident evidence. That gate is what raises quality, cuts review cost, and produces the kind of audit trail compliance teams ask for.

06

Test-first, build to green

With the harness in place, the tests come first. I write and lock them before any implementation exists, then the build runs until every one of them passes green. The bar is already set before the work starts.

07

Synthesize and build in chunks

The pieces are assembled into one coherent spec, then implemented chunk by chunk and reassembled into the finished whole.

The result

Institutional-grade output from a process that repeats. Rigor in specification far outweighs complexity in implementation: the design is the hard part, and the same discipline applies whether the target is an enforcement layer or a research platform.

← Index

Governance / Standing documents

Playbooks

Every agent team I run operates under fine-tuned written governance. Each document is tested and tuned in use: I run builds against it, measure output quality, and tighten the rules where output drifts. The work is slow up front and compounds once the agents are deployed. Every build that follows inherits the full standard, loaded into the agents’ context on each design pass and enforced mechanically by the harness. Excerpts below; full documents are available on request.

3 documents · 2,500 lines of standing governance · loaded on every design pass

Enforced by GigaHarness →

The documents

01

System Design Mandate, v4.1

The standard the architect agent is held to. It defines when a design is invalid, what makes a decision material, and the failure modes it exists to prevent: hallucinated facts, premature completion, silent fallbacks, source confusion, phase bleed. A missing fact halts the design.

“The architect is not a task completer. The architect is the owner of system-level correctness.”

“A design is invalid if it: invents repo facts; substitutes plausible behavior for grounded behavior; completes when a blocking fact is missing… permits silent fallback where fail-closed behavior is required.”

02

Engineering Ethos, v4.1

Ten principles bind every design at once, including correct by construction, single source of truth, fix at the root, and fail loudly, fail fast, fail safely. Each principle carries an operational test, required evidence, and a list of forbidden misuses, and the architect fills a compliance table before handoff.

“The discipline is symmetric: never omit what closes a credible high-impact failure, and never add what closes nothing.”

03

Formatting Guide, v8

How designs are expressed so a builder can’t misread them. It fixes the structure, the source-citation rules, and an ambiguity test: if two competent builders could implement the design differently, the design is incomplete.

“The required structure in this guide is a floor, not a style preference.”

Proof this works

Operating under these documents, an independent adversarial audit surfaced six correctness defects a build agent had certified as clean. The governance layer caught what the builder missed.