A classic red multi-tool pocketknife, fanned open: blade, screwdriver, scissors, and corkscrew

Jack Gewirz

The index

I build autonomous AI systems — agent networks, data pipelines, and products that run themselves.

Projects

Systems that run themselves — consulting, markets, personal builds.

  • Automation Consulting · 2
  • Kalshi · 1
Explore Projects

Stack

The programs, platforms, and integrations behind everything.

Claude CodeCodexPythonTypeScriptPostgreSQLNeonMongoDBAWSKubernetesVercel34 programs
Explore Stack

Skills

Seven capability areas, one operator.

  • AI & agents
  • Growth & marketing
  • Generative media
  • Engineering
  • Infrastructure
  • Data systems
  • Product & design
Explore Skills

Poker

Four years professional — played as a data problem.

Global earner, 2023
Top 50
Championship titles — 6 NLHE · 2 PLO
8
Win rate over 150,000+ hands, 2024
8bb/100
Explore Poker

Projects

Systems that run themselves — consulting, markets, personal builds.

Automation Consulting

Approval is the only human step

Autonomous Ad Engine

A paid-ads engine that generates, measures, and re-invests in its own creative — humans only approve.

  • Meta Ads
  • Agent SDK
  • Higgsfield
  • Human-in-the-loop

Proof pack — vault-compiled, human-gated, shipped

Static ad plate — the mint-tin brand device selling the Travel Agent: real flights, one chat, four experts. Generated in one locked brand voice.
Feature-demonstration static — before/after color-season analysis with a composited testimonial, styled by the same vault.
Hybrid UGC spot — outfit panic to packed-and-ready; AI presenter with the real app UI composited in. 15 s, shipped to Meta.

How it's built

The problem

Staitmint — an iOS AI personal assistant — needed paid-acquisition creative at startup volume: static plates, feature demos, UGC-style video, all recognizably one brand. The classic failure mode is drift: ten generated ads that read like ten different companies, with no way to trace which creative decision earned which result. The brief was a system that generates at volume, holds one voice, and accounts for itself — without a creative team.

The system

The brand lives in an Obsidian vault that is simultaneously human-editable documentation and a typed database: voice, lexicon, and personas in plain notes, every one schema-validated so a malformed edit fails the build instead of shipping off-brand. Exactly one voice is active at any time. A compile step turns the vault into generation context — and stamps every asset with a voiceVersion, the SHA-256 of the exact inputs that produced it. Attribution exists before the ad does.

Generation runs on Higgsfield: avatar-led UGC video and clean static plates, with the real app UI composited in deterministically — never AI-redrawn. Finished creative lands in Telegram, and approval is the only human step: the bot delivers each asset, one tap approves or rejects, and the decision commits straight back into the vault.

Approved creative ships to Meta, campaigns scaffolded through the official meta-ads CLI. Performance returns through the Graph API as per-ad, per-day rows joined to each asset's voiceVersion, with GA4 carrying the on-site funnel — so spend and response attribute to the exact voice revision that generated the ad, and the creatives that perform seed new campaigns. The loop closes itself.

What it produced

The creative set above is the output: two static ad plates and a hybrid UGC spot, generated in one locked brand voice and shipped to Meta. Behind them sits the working machinery — a schema-validated brand vault, per-asset voiceVersion stamping, a one-tap Telegram approval pipeline, and per-ad daily insight ingestion joined to creative attribution. A full-loop architecture where a human touches exactly one step.

  1. Obsidian

    VaultObsidian

    The brand as a database: voice, lexicon, and personas in human-editable notes, schema-validated on every build — exactly one voice active at a time.

    Obsidian vault · Zod schemas

  2. Claude

    CompileClaude

    The vault compiles into generation context, and every asset is stamped with a voiceVersion — the SHA-256 of its exact inputs — before anything is generated.

    Claude Agent SDK · TypeScript

  3. Higgsfield

    GenerateHiggsfield

    Image and video ads in one locked identity: avatar UGC, static plates, deterministic composites — the real app UI is composited, never AI-redrawn.

    Higgsfield MCP · Higgsfield REST API

  4. Telegram

    ApproveTelegram

    The only human step. The bot delivers finished creative; one tap approves — and the decision commits back into the brand vault.

    Telegram Bot API · GitHub

  5. Meta

    LaunchMeta

    Approved creative ships to Meta, campaigns scaffolded through the official meta-ads CLI.

    Meta Ads · meta-ads CLI

  6. MetaGoogle Analytics

    TrackMeta · GA4

    Insights return per-ad, per-day and join to each asset's voiceVersion — performance attributes to the exact voice revision that produced the ad.

    Meta Graph API · GA4 Data API

  7. winners seed new campaigns

Replaced multiple $60K/yr roles

CatchFlow — Seafood Price Intelligence

Email-in, database-out: a platform that turns the daily flood of supplier price sheets into one normalized, queryable seafood price database.

  • AI extraction
  • Data normalization
  • Postgres
  • Multi-tenant SaaS

Proof pack — vault-compiled, human-gated, shipped

The live dashboard — 198 normalized items across 45 suppliers, every price comparable per-pound the morning it arrived.
The in-app assistant quotes live prices mid-chat and takes a delivery order — AI on top of the normalized data, not instead of it.
Purchase orders placed through the assistant — item, supplier, quantity, total, dispatched over SMS.

How it's built

The problem

A seafood buyer's inbox is a data-entry job in disguise: dozens of supplier price sheets a day, in formats that agree on nothing — free-text lists, photographed posters, multi-page PDF catalogs, each with its own abbreviations, size codes, and units. The same fish arrives under 61 different spellings; weights hide in 438 notations; prices come per pound, per case, or per piece. Consolidating that by hand is a full-time role. The brief was a pipeline whose success criterion is zero manual intervention for standard formats — every price comparable, per-pound, by species, the same morning it arrives.

The system

Two ingestion paths converge on one pipeline: a tiered scheduler polls a central Gmail/Outlook inbox — every twenty minutes through the 5am–2pm market peak, tapering overnight — while each customer org also gets its own Postmark forwarding address that suppliers email directly. Every message is processed in isolation under its own timeout, so one malformed sheet never stalls the batch. An orchestrator then classifies each email and dispatches across three modalities: GPT-4o in JSON mode for text, Claude Sonnet vision for photographed posters, and a two-stage spatial-reconstruction path for PDFs.

Normalization is the actual product. Eight sequential, config-driven steps decompose a free-text listing into canonical structure — species (longest-match against 500+ aliases, the matched name stripped so "Tuna Tuna" can't happen), product form, preparation, grade, weight, and origin — then convert every price to a common per-pound unit and validate it against a reference database that flags outliers. The vocabulary is data, not code: adding a species is two JSON edits picked up on restart. It was built against a real corpus of 1,564 records from 38 suppliers, where five tuna species alone wore 61 different names.

Canonical items land in org-scoped Neon Postgres behind DB-level MD5 dedup, with the original supplier documents archived to Cloudflare R2. Buyers work from a live dashboard, a tuna market board, Google Sheets and CSV export, and a 7am summary email — every query scoped by organization, every route gated by Stripe subscription state. Underneath sit the guardrails that make it a business: three-tier idempotent deduplication, per-email and per-call timeouts, retry with backoff, a watchdog that resets a wedged scheduler, and a self-authored 74-issue audit with file-and-line references.

What it produced

The walkthrough above is the buyer-facing surface; behind it runs the machinery. A config-driven lexicon of 500+ species aliases, 26 product forms, and 40+ preparation codes collapses the chaos — 61 tuna spellings into one species record, 438 weight notations into parsed sizes — into 198 normalized items across 45 suppliers, every price comparable per-pound the morning it lands. It ships as a multi-tenant SaaS with three Stripe tiers and a flag-gated five-Worker Cloudflare edge suite designed behind circuit breakers — the work that once took multiple data-entry roles at roughly $60K a year, run to zero manual touch.

  1. GmailOutlook

    IngestGmail · Outlook

    Two paths into one pipeline: scheduled Gmail/Outlook OAuth polling plus a per-org Postmark forwarding address — every email handled in isolation under its own timeout.

    Gmail API · Outlook OAuth · Postmark

  2. OpenAI GPT-4oClaude

    ExtractGPT-4o · Claude

    An orchestrator classifies each email and dispatches by modality — GPT-4o JSON mode for text, Claude vision for photographed posters, spatial reconstruction for PDFs.

    OpenAI GPT-4o · Claude Sonnet vision

  3. TypeScript

    NormalizeNode · TS

    The actual product: eight config-driven steps turn a free-text listing into canonical species, form, grade, weight, and origin at one per-pound price. 500+ aliases; 61 tuna spellings collapse to one record.

    8-step lexicon · reference-DB validation

  4. Neon PostgresCloudflare R2

    StoreNeon · R2

    Canonical items land in org-scoped Neon Postgres behind DB-level MD5 dedup; the original supplier documents archive to Cloudflare R2.

    Neon Postgres · Cloudflare R2

  5. Google SheetsSummary email

    SurfaceSheets · Email

    Buyers get a live dashboard, a tuna market board, Google Sheets and CSV export, and a 7am summary — every query scoped by organization.

    Google Sheets API · Summary email

  6. every morning, re-normalized

Kalshi

Kalshi arbitrage engine — sportsbook consensus and Kalshi price converging at tip-off, over the Python, Redis, QuestDB, Docker, AWS stack

15% ROI over 250 positions — $4,700 net

Sports Arbitrage Engine

A co-located convergence engine on Kalshi: sportsbook consensus read against market price, profit captured before tip-off.

  • Python
  • AWS co-location
  • Kelly criterion
  • Prediction markets

How it's built

The problem

Kalshi quotes sports as probability — a contract priced in cents on the dollar. Sportsbooks quote the same games as odds, sharpened by a volume of action the prediction market never sees. Convert a book's line into implied probability and the two venues become directly comparable: wherever they disagree, one of them is wrong, and it is usually the thinner market. The system was researched like a discipline before it was treated like a project — how convergence engines are structured, why their edges decay, why the race is decided in transit time — and then designed end-to-end in the head: every service, every data path, every failure mode, planned through before the first line of Python. What got built was that plan.

The system

The strategy is convergence, not gambling. Lines from other sportsbooks are normalized into implied probabilities and blended into a consensus; Kalshi's order book is read against that consensus, and the gap between them is the edge. Positions enter where the gap is wide, and exit on the close — mispricings normalize as tip-off approaches, so the profit is the percentage the market moves as it corrects, captured before the games ever start.

Latency is engineered, not hoped for. The stack deploys by docker-compose into the AWS region closest to Kalshi's own servers — round trips in intra-region milliseconds instead of the tens a cross-country hop costs — with hot odds held in Redis so the trading loop reads from memory, not the network, and QuestDB recording fills and P&L as time series. The runner cycles four services: ArbPipeline maps Kalshi markets to the consensus and flags edges, TradingService re-validates quote freshness at the moment of execution so no order fires on a stale line, TakeProfitMonitor manages TP/SL exits, and SettlementService finalizes P&L on close.

Sizing is Kelly criterion, disciplined by uncertainty: every edge carries a confidence interval, and the stake scales to it — wide interval, small bet; tight interval, full fraction. The same math that finds the mispricing decides how much bankroll it deserves.

What it produced

250 settled positions at a 15% ROI — $4,700 net profit, every exit taken before game time. The architecture below is the machine that did it: one latency-budgeted loop from odds ingestion to recorded P&L, running unattended against a live exchange.

System architecture

The complete flow from odds ingestion to P&L recording.

INFRASTRUCTURE (docker-compose)
Redis (hot odds) · QuestDB (P&L) · Postgres (optional)
ODDS INGEST
Odds API →
Redis →
QuestDB
TRADING RUNNER (main loop)
 
1. ArbPipeline.run_cycle()
Kalshi → Map → Consensus
→ EdgeDetector → Signals
2. TradingService.trade_batch()
Fresh validate → Size → Exec
3. TakeProfitMonitor
TP/SL → Exit → QuestDB
4. SettlementService
Finalized → P&L → QuestDB

AI ETF

Personal investment progress · my own thesis

The inversion is the story

A personal project I took on to invest my own money — a thesis-driven AI-infrastructure portfolio in the toll booths of the AI buildout, not the traffic. Every position was constructed the hard way: months of research into where the sector's growth actually accrues, high-level market analysis, SQL run over my own bank and brokerage data, SEC filings mined for the fundamentals that matter, and AI used to pressure-test each claim before a dollar moved. The plays that came out of that work run against a written 4-tier allocation framework and read honestly: the book is Tier-4-heavy and Tier-1-empty relative to its own bands, and that measured gap is what drives the rebalancing plan.

  • My own capital on the line
  • Deep sector research & analysis
  • SQL over bank & brokerage data
  • SEC filings & fundamentals
  • AI used to reinforce every thesis claim
Live board · delayed quotes
MRVL39.7%
NBIS27.3%
P14.9%
CRWV8.6%
SYM4.9%
FIG4.6%
Book day move

snapshot · Jul 14, 2026

Insider tape · SEC Form 4

Source: SEC EDGAR Form 4 — insiders' own public filings.

Capabilities

The stack behind the systems

  • Claude Code
  • Codex
  • Python
  • TypeScript
  • PostgreSQL
  • Neon
  • MongoDB
  • AWS
  • Kubernetes
  • Vercel
  • Render
  • Cloudflare
  • Google Cloud
  • Stripe
  • GitHub
  • n8n
  • Obsidian
  • Notion
  • Gmail
  • Outlook
  • Google Sheets
  • Excel
  • Microsoft Office
  • Figma
  • Telegram
  • WhatsApp
  • Google Ads
  • Google Analytics
  • Meta Ads
  • ElevenLabs
  • Higgsfield
  • ComfyUI
  • Apify
  • OpenClaw

APIs

Hundreds of third-party APIs integrated across production systems — and custom APIs designed and built to expose my own. Integration is the connective tissue of everything I ship: market data feeds for the arbitrage engine, payment rails for autonomous commerce, messaging platforms for agent networks, and generation endpoints for media pipelines.

  • Google Workspace
  • Google Maps
  • Notion
  • Stripe
  • Telegram
  • WhatsApp
  • Apify
  • ElevenLabs
  • Higgsfield
  • Prediction-market & sportsbook data feeds

MCP servers

Dozens of MCP servers wired into daily-driver agent systems — plus custom MCP servers designed and built from scratch, giving agents first-class access to my own databases, CRMs, and operations.

  • Notion
  • Google Workspace
  • Google Maps
  • Custom-built servers — CRM, lead databases, ops

Skills

Seven capability areas, one operator.

AI & agents

  • Claude Code (expert)
  • Autonomous system design
  • Agentic workflow design
  • Custom agent systems (Telegram, WhatsApp, OpenClaw)
  • MCP servers — built and integrated (dozens live)
  • n8n workflow automation
  • Open-source model training
  • Prompt & context engineering (Obsidian knowledge bases)

Growth & marketing

  • Autonomous outreach (cold email + AI cold calling)
  • Google Ads
  • Meta ads scaling
  • AI ad creation (image & video)
  • Autonomous marketing campaigns
  • SEO & GEO (generative engine optimization)

Generative media

  • Higgsfield
  • ComfyUI custom workflows
  • ElevenLabs
  • Multi-model content pipelines

Engineering

  • Python
  • TypeScript
  • System design
  • API design & creation (hundreds integrated)
  • SQL (Postgres / Neon)
  • MongoDB
  • Web scraping (Apify)

Infrastructure

  • AWS
  • Kubernetes (scaling & management)
  • Render
  • Vercel
  • VPS administration
  • GitHub
  • Stripe

Data systems

  • Normalization & lexicon pipelines
  • Lead databases & rating systems
  • CRMs & scheduling systems
  • Notion integration
  • Google Workspace & Maps APIs

Product & design

  • Figma
  • Web & app design
  • App Store delivery
  • Content & brand strategy

2021–2024

Four years as a professional poker player

Before software, poker — played as a data problem.

Top 50
Global earner, 2023
8
Championship titles — 6 NLHE · 2 PLO
8bb/100
Win rate over 150,000+ hands, 2024
4 yrs
Professional play, 2021–2024

From 2021 to 2024 I played poker professionally, primarily online — No-Limit Hold'em first, Pot-Limit Omaha alongside. In 2023 I ranked among the top 50 global earners, with eight online championship titles — six in No-Limit Hold'em, two in Pot-Limit Omaha.

The edge was never intuition; it was analysis. I dissected large databases of opponent data with AI, ran solver-based study and Monte Carlo simulation, and turned player tendencies into exploitable strategy. In my final year, that system sustained an 8bb/100 win rate at a $400 average buy-in.

The methodology proved teachable: I coached both professionals and amateurs on the same analytical approach — database work, solver study, and tendency modeling.

Poker built the habits that now run my engineering work: probabilistic thinking, ruthless quantification of edge, and calm decisions under variance. In 2024 I retired from full-time play and pointed the entire toolkit at autonomous systems.

The receipts — tracker graphs, unretouched

Lifetime online tournament profit — tracked across ~6,500 games.
Second account — the same climb, ~1,100 games.