How it's built

The detail behind the homepage, for the person who will be asked "is this real?". Every claim here names the file or public page it comes from.

Support Coach extension

Support Coach checks a support agent's reply before it is sent. It has three layers:

  1. Instant local rules. Runs in the browser with no network call and no AI cost (packages/rules).
  2. An optional AI check when the agent pauses typing.
  3. A pre-send AI check with a suggested rewrite that keeps every fact and instruction in the agent's draft (packages/ai, sanitizeRewrite).

Permissions

The manifest asks for one permission, storage, and five host patterns covering Zendesk, Intercom and Zoho SalesIQ. Source: apps/extension/manifest.json.

What leaves the browser

Four fields, and never the customer's messages: draft_text, triggered_rules, local_score, draft_hash. Source: apps/extension/src/lib/apiClient.ts.

Agent work queue and permissions

This part is my own system, in a private repo, so there are no file links here. I show the code and the test runs on a call. Everything below is built and tested on my own work and on sample data. None of it has run for a client yet.

One agent per job

Work is a queue of jobs split into stages. A worker claims a stage with a time-limited lease and a fencing number, so a worker whose lease ran out cannot write over the one that took over. Each stage has an idempotency key, a budget and a write scope that does not overlap with any other running stage. A failed stage is retried once, then blocked for a person.

Approval before any outside effect

Only the app starts a run, never another agent. A person approves before work starts, the result lands as a draft pull request with a preview, an independent model reviews it, and the person approves once more before it ships.

Permissions as their own record

What a person may do is a separate record from what the business wants, and the two never mix. Access is the overlap of sign-in, tenant, department, connector scope, sensitivity and per-record grants. Titles and request wording grant nothing, and tests cover both, along with prompt injection. Levels 0 to 3 are built: show, read, draft, then one named action after a yes. The code refuses anything above level 3.

Plan-first execution

A prototype where the model writes a whole plan against typed capabilities, and the host checks permission, call count, bytes and time on every call and refuses replays. It reads the real queue state before and after each call inside a read-only transaction. It is a design study, not production enforcement.

How it is tested

App tests, database tests on an in-process Postgres, race tests for claims and leases, Python unit tests, and end-to-end simulations of the queue. The suites run on every change. Counts change daily, so I don't print them here.

Tests

The rules engine, the AI layer, the backend and the extension each have their own automated tests.

The three demos

The engines behind the case studies, on synthetic data. The local rules engine is the real deterministic code. The AI layer here returns sample output. No model is called.

Layer 1 (local rules) runs the real deterministic code. The AI layer here returns sample output. No model is called.

Fields that leave the browser (apps/extension/src/lib/apiClient.ts)

{
  "draft_text": "Like I said, you need to reconnect it yourself. It's not a bug on our end, and there is nothing I can do from here.",
  "triggered_rules": [
    "dismissive_harsh",
    "blame_language",
    "missing_ownership",
    "cold_transactional"
  ],
  "local_score": 72,
  "draft_hash": "ead21245a262ef2d"
}

Layer 1: local rules (no AI)

Local score: 72/100

This could read as dismissive or abrupt to the customer.

Example: "I can help get this working for you right now. Let me walk you through the steps."

Rule families fired: dismissive_harsh, blame_language, missing_ownership, cold_transactional

Layer 3: pre-send check (sample output)

Overall risk: high

Identifies the reconnection requirement needed to resolve the issue.

empathy
2/10
ownership
2/10
clarity
9/10
actionability
9/10
professionalism
2/10
de escalation
2/10
conciseness
9/10

Suggested rewrite

I can help you get this reconnected. This happens when the local connection token resets rather than a platform outage, and I can walk you through reconnecting it right now so everything syncs cleanly.

Capabilities

Browser Extensions (Manifest V3 & Complex DOM Injection)

Status
Working Production Implementation
Where it is
Support Coach extension, live on the Chrome Web Store (TypeScript, Vite + CRXJS, Shadow DOM).
What it shows
Platform-adapter DOM architecture across Zendesk (contentEditable), Intercom (contentEditable), and Zoho SalesIQ (<textarea> with synthetic input/change event dispatch); elementsFromPoint z-order visibility gates and geometric overlap checks to avoid modal false positives; edit-box focus guards; passive self-diagnostics; minimal manifest permissions.
Problem it solves
Teams need an in-page AI copilot or compliance checker overlaid inside Zendesk, Intercom, Zoho, or a web CRM without breaking host-page editors, stealing cursor focus, or requesting invasive <all_urls> permissions.

Support Operations Tooling & Real-Time Pre-Send Coaching

Status
Working Production Implementation
Where it is
Support Coach extension packages/rules, packages/ai and apps/backend. The rules engine, the AI layer, the backend and the extension each have their own automated tests.
What it shows
3-layer cost/latency architecture: Layer 1 local rules engine (no network call, works offline, with co-occurrence gating so plain factual replies are not flagged); Layer 2 paused-typing AI check; Layer 3 pre-send AI check with a deterministic sanitizeRewrite step that keeps every factual instruction in the agent's draft.
Problem it solves
Support agents send blame-heavy, dismissive, or dead-end replies in live chat when rushed, and managers only discover the escalation days later during post-hoc QA.

Multi-Tenant SaaS Development & Billing Lifecycle

Status
Working Production Implementation
Where it is
Support Coach dashboard at www.supportcoach.io (Next.js App Router, TypeScript, Supabase Auth and PostgreSQL, Paddle v2 billing) and the extension admin app.
What it shows
End-to-end multi-tenant SaaS with organization-scoped queries, Paddle checkout and signature-verified webhook lifecycle, server-side seat enforcement with a daily seat true-up, per-seat monthly AI spend ceilings (aiCostControls.ts), and a security and tenant-isolation audit of the app's data access.
Problem it solves
Founders need a production-ready Next.js + Supabase + AI SaaS with working subscription billing, seat management, and per-tenant AI cost caps so a trial user cannot run up unbounded AI spend.

Data Analysis, Transcript QA & Topic Reporting

Status
Production, with some features not yet released
Where it is
Support Coach dashboard worker (PDF transcript processing, charts and PDF reports) in production.
What it shows
PDF transcript ingestion with duplicate detection, idempotent job claiming, sender misattribution repair, domain-specific QA guardrails (exempting remote screen-share gaps of 5 minutes or more and scoring abandoned chats neutrally), AI follow-through tracking across later chats with manager override, and AI-proposed, human-approved product confusion topics.
Problem it solves
Product and CX leaders have thousands of raw support transcripts but cannot see which product areas confuse customers or whether agents apply coaching feedback.

AI Integrations, Multi-Agent Governance & Human-in-the-Loop Ops

Status
Working Personal Platform (Internal Use)
Where it is
A private operations platform I run for my own work (Next.js, React, Supabase Realtime), with versioned role prompts and evaluation suites.
What it shows
Role-as-code prompt management, multi-provider routing (Anthropic, OpenAI, Google Gemini, xAI Grok) with weekly quota pace tracking, two-tap mobile approval cards with a hidden decision prediction and a decision journal, a cross-agent task board that cannot approve anything, and scripts that keep personal and business data apart.
Problem it solves
Executives and operations teams want multi-agent automation across Claude, OpenAI, and Gemini without risking unauthorized emails, spend, or data leakage across accounts.

Workflow Automation & Auditable Outbound Pipelines

Status
Working Internal Implementation
Where it is
An internal outbound pipeline where the owner approves every message before it is sent (outbound.ts, outboundReviewer.ts, outboundInstantly.ts, with unit tests).
What it shows
Prospect state machine (research, contactability, owner approval, evidenced outcome), an AI company-fit reviewer, a deterministic claim checker, campaign sync with a manual send-later mode, and bounce-rate circuit breakers.
Problem it solves
B2B teams want automated lead qualification, personalized first-line research, and outbound sequencing with hard human approval gates and automatic bounce and claim checks.

APIs, Webhooks & Privacy-First Third-Party Integrations

Status
Working Production + Staged Connectors
Where it is
Paddle v2 webhooks, a dependency-free PostHog batch forwarder (analytics.ts), first-touch attribution middleware, a Zoho SalesIQ REST API v2 client (salesiq.ts), Resend REST API, Cloudflare Turnstile verifier.
What it shows
Server-side-only telemetry forwarding (no third-party scripts in the extension or marketing pages), timing-safe webhook verification, Zoho multi-data-centre OAuth refresh with body-level error and throttle handling, and hedged AI calls with nested timeouts.
Problem it solves
Companies need reliable third-party API and webhook integrations (help desks, billing, analytics, LLMs) that respect strict privacy policies and never block the primary user path.

Knowledge Systems & Evaluated Prompt Engineering

Status
Working Internal Implementation
Where it is
A written handoff protocol, evaluation suites, a lessons log, and an experiment register (docs/EXPERIMENTS.md in the Support Coach repository).
What it shows
Append-only knowledge handoffs that treat external content strictly as data (prompt-injection defence), pre-registered experiment hypotheses with decision gates, and test-set regression checks before any prompt or sanitizer change ships.
Problem it solves
Teams building with LLMs suffer from prompt drift, regressions when fixing isolated bugs, and unverified product claims because they lack structured evals and state handoffs.

Limits

  • Browser Extensions (Manifest V3 & Complex DOM Injection). Chrome/Chromium browser only (does not run inside native Windows/macOS desktop help-desk apps such as the SalesIQ desktop client); Chrome blocks content scripts and password-manager autofill inside chrome-extension:// popups.
  • Support Operations Tooling & Real-Time Pre-Send Coaching. Intentionally draft-only (does not read customer messages, trading full conversation context for privacy); no customer satisfaction or resolution-time gain has been measured.
  • Multi-Tenant SaaS Development & Billing Lifecycle. Plan-tier feature gating is not yet hard-enforced.
  • Data Analysis, Transcript QA & Topic Reporting. Product confusion topics, Zoho SalesIQ auto-sync and coaching notifications are built but not yet released.
  • AI Integrations, Multi-Agent Governance & Human-in-the-Loop Ops. Single-owner deployment; subscription usage meters need a scheduled browser reader because providers do not expose subscription usage APIs.
  • Workflow Automation & Auditable Outbound Pipelines. Cold-email conversion is not yet proven.
  • APIs, Webhooks & Privacy-First Third-Party Integrations. The public reply checker endpoint is built but switched off until bot protection is configured.

Fifteen minutes, and you will know if it's a fit.

Tell me what your team is dealing with. I will tell you whether I can help and what it would cost.

Book a 15-minute call

Prefer to write?

Send a short brief