What I've built in the field.

Context

I hand an agent ambiguous goals all day. Build this, research that, fix the site. A single chat thread is the wrong container for that work: it doesn't survive a restart, and nothing in it stops an agent before it does something I can't undo.

Problem

I wanted those goals to become work I could actually see and trust. Broken into pieces, each piece assigned to the right agent, tracked somewhere durable, and halted at the exact points where a wrong move costs money or fires off a message I can't recall.

System built

I built an orchestrator that breaks a goal into worker-sized tasks, routes each one to a specialist agent, and tracks state on a shared board. Workers hand off written context to each other, so the next agent picks up where the last one left off.

Technical pattern

Orchestrator and workers, with a dependency graph so a task waits for its parents before it runs. The gate is the part I care about: any irreversible side-effect, whether a payment, an outbound message, or a deploy, stops and waits for me to approve it. Research, drafting, and analysis run unattended up to that line.

Governance

The approval gate is wired into the orchestrator itself, so a model can't talk its way past it. Every run leaves behind an artifact and a written summary on the board, so I can read back exactly what each agent did and why.

Outcome

A vague goal becomes tracked work that survives a restart and stops for me at the parts that bite. This page was decomposed and drafted that way.

Context

I turn messy research, experiments, and notes into things I can publish in my own voice.

Problem

Synthesis is the slow step. And anything finance-adjacent needs a privacy and disclosure check before it goes anywhere near public.

System built

A pipeline that captures source material, runs a synthesis loop, and drafts a first version, with a privacy and disclosure pass wired in as the required final stage.

Technical pattern

Ingestion, then a synthesis loop, then voice-preserving generation, then a hygiene gate. The screen-recording scrub and disclosure checks are a step the pipeline isn't allowed to skip.

Governance

The PII scrub, screen-capture cleanup, and disclosure checks run before anything publishes. Nothing publishes on its own.

Outcome

Research becomes drafts that sound like me, with the privacy pass baked into the run so it can't quietly get forgotten.

Context

A bank's shared back-office runs on multi-step, multi-team workflows: loan processing, document checks, compliance, sign-off. Each case moves by hand from one queue to the next.

Problem

Every hand-off is a place a case stalls. The institution wanted to run the process end-to-end without losing the audit trail or the control points a regulator expects at the parts that carry risk.

System built

I designed a multi-agent system that runs a back-office process from intake to completion: a workflow orchestrator coordinating specialist agents for document comparison, compliance, signature and verification, and straight-through processing, over a shared memory layer wired into the bank's enterprise systems.

Technical pattern

An orchestrator agent coordinating role-specialized workers, each owning a single step and passing state through a shared memory store. Cases flow straight through, with a human pulled in only at defined risk gates rather than at every step.

Governance

Audit-grade traceability of every agent action, with data governance, role-based access, and responsible-AI policies wired in from the start. Human-in-the-loop is reserved for the risk gates, and every action is logged so the case holds up to review.

Outcome

A reference design for taking a multi-team back-office process end-to-end with agents, where the audit trail and the risk gates are part of the architecture rather than bolted on afterward.

Context

A firm wanted to turn unstructured inbound email, broker messages, into structured trade data automatically. The model gets it mostly right, but mostly isn't good enough when the output feeds downstream systems.

Problem

An extraction model that's right most of the time still produces errors you can't see. There was no objective signal for whether a given output could be trusted, or for which prompt change actually made things better instead of just different.

System built

I designed and prototyped a generator-plus-judge pipeline: an analyzer model extracts structured rows from each email, a judge combining deterministic rule checks with an LLM scorer returns an accept-or-reject verdict with confidence and rationale, and uncertain cases branch out to a human.

Technical pattern

Generator to structured output to judge (rules plus LLM) to a confidence-scored verdict to a feedback loop. Scoring the judge's output against a ground-truth set drives iterative prompt tuning, so improvements are measured against data instead of guessed, and low-confidence cases route to review instead of flowing through silently.

Governance

The judge is the gate. Deterministic rules catch schema and invariant violations before the LLM scorer weighs in, low-confidence outputs are held for a human rather than trusted, and every verdict carries a rationale that can be audited.

Outcome

A reusable evaluation pattern that turns 'the model seems fine' into a measured, confidence-scored signal, and turns prompt tuning from guesswork into something driven by ground-truth deltas.

Context

Enterprise agent demos often become a generic chat window with little business context or a one-off build that needs specialist setup before each session.

Problem

I wanted one self-serve experience that could cover different industries and personas while keeping a coherent end-to-end story. The audience also needed a way to trace each answer back to its evidence.

System built

I built and hosted a self-serve demo where a user picks an industry and persona, then works through a business scenario with the agent. The app uses synthetic, domain-specific artifacts and retrieves from several source types to synthesize an answer. Users can open the supporting sources. The interface leads with the business flow and keeps technical drill-downs available.

Technical pattern

Keep the agent and retrieval pipeline fixed, and swap the industry/persona context and supporting artifacts as one scenario layer. The same flow supports different scenarios without a rebuild. Progressive disclosure starts with the selected scenario and leaves the mechanics available on demand.

Governance

The demo uses synthetic data and restricted access. Citations and source inspection let reviewers trace an answer. The prototype is not presented as a customer deployment or production system.

Outcome

Reviewers could run the self-serve prototype, and early use informed the next iteration. Changing the industry or persona did not require a separate build.