I build GTM systems that run on AI.
I design the pipelines, models, and data behind how GTM teams execute. Then I automate the work itself.
Status
Open to new work
from September 2026
- AI-native GTM systems
- Growth engineering & data
Selected Work
A proactive GTM engine, built end-to-end
The challenge
Pipeline was 100% inbound: auto-scored, one manual reply each. It worked, but it was the whole motion. The brief: build the next one.
What I built
An outbound engine that treats public developer activity as intent. It pulls every signal (stars, forks, installs, container pulls, telemetry, hiring), enriches each contact, and scores it on ICP fit plus signal strength.
- Deduped daily against inbound, so no one gets double-touched.
- A Python scoring module (stdlib only) makes every ranking auditable.
- An LLM copy layer drafts each sequence, gated by deterministic rules before send.
- A self-improving loop: every conversion re-weights the model and grades the copy that worked.
The outcome
Shipped as a live app plus a runnable scoring model. Every number came from a real public API. Runs on ~0.1 FTE once live.
Production multi-agent marketing system
The challenge
A 30+ person marketing team with zero agentic infrastructure. Everything ran on manual triggers.
What I built
A 24/7 system where orchestrator agents coordinate subagents in parallel. Content, data refresh, reporting, and knowledge upkeep all run without manual triggers.
- Self-improving loops: weekly agents propose rule changes; monthly cycles auto-approve them only if benchmarks improve.
- RAG memory over a ~1,000-doc vector-indexed wiki, with semantic search and automated pruning.
- Decay-weighted scoring that keeps high-value knowledge within token limits.
- Eval frameworks: skill-trigger accuracy, output quality, and retrieval precision, with regression tracking.
The outcome
Decentralized multi-agent swarm, no orchestrator
The challenge
The multi-agent system above runs on a supervisor: orchestrator agents decide who acts next. That's one real pattern, but not the only one. I wanted to test whether a genuinely decentralized model, where no single agent or human ever picks the next move, could actually hold together in production.
What I built
Independent roles coordinate through file-based mailboxes and a Holocracy-style governance mechanism: any role can file a proposal or an objection, and a proposal integrates only once every other role has had a turn to object and none did — computed purely from timestamps in an append-only audit log, never decided by an LLM or a human. LangGraph handles only the mechanical parts (state, parallel fan-out, routing); every real judgment call happens inside a headless Claude Code subprocess, schema-validated on the way out.
- Found and fixed real permission-scoping bugs by testing directly against the CLI instead of trusting its docs — one flag was silently overridden by a default, another blocked tools it claimed to support.
- Built a local observability dashboard: cost-per-role tracking, an objection matrix, proposal-lifecycle metrics, all computed from structured logs at zero added inference cost.
- The same framework runs multiple use cases via swappable per-pack role configs — a new use case is a new config directory, not new framework code.
The outcome
Running against a real, live case, not a demo: sourcing and screening real job postings, drafting tailored applications, with a dedicated fact-checking role enforcing a hard no-fabrication rule.
Incrementality testing framework
The challenge
Spend ran on platform-reported conversions, numbers the platforms grade themselves on. No honest read on what was incremental.
What I built
A from-scratch incrementality framework in Python on the ads-platform APIs. Lift experiments that separate causal impact from correlation.
- Set the experimentation culture behind today's agent-driven testing.
- Wired results into budgeting, so spend followed proven lift.
The outcome
GTM data infrastructure & conversion tracking
The challenge
Marketing, product, data, and legal ran on inconsistent signals. In-platform and backend numbers disagreed, and the pipeline the agentic layer would need didn't exist.
What I built
The foundation the agentic layer runs on: end-to-end Segment CDP, server-side CAPI events, and lifecycle-stage conversion events, all GDPR-compliant.
- Closed the gap between in-platform and backend data with automated reporting.
- Coordinated marketing, product, data, and legal to keep pipelines clean.
The outcome
Open source
Tools and agent skills I've built in the open.