I'm Josh Cook. In 19 months I took Buzzword Strategies from zero to $1M+ ARR with no outside capital, by building the multi-agent platform that does the delivery. 24 named agents, 169 packaged skills, a local GPU inference tier and a client-facing conversation AI, all in production for 21 accounts on a team of eight.
Every figure on this page came off a system you can watch running.
Buzzword delivers paid media, creative production, CRM automation, lifecycle email, landing pages, lead magnets and performance reporting for 21 clients. That workload normally needs thirty people. It runs on eight, because the delivery layer is software, and the software is organized the way a good agency is: specialists with clear remits, a router above them, and a gate before anything ships.
An agent I run the company through from my phone. I text it, it works out what I meant, and it acts. There is no menu to learn and no command syntax to remember.
The conversational turn is read-only by design, so asking it a question can never change anything as a side effect. Work that changes state leaves as a dispatch into its own lane with its own cap, log and timeout. Anything a human will read leaves as a draft and comes back for approval.
A guardian process keeps the lane alive with an outbound heartbeat. An inbound webhook cannot cold-start a machine that has already stopped listening.
Amanda is the conversation AI deployed into any client CRM instance by slug: she books, qualifies and follows up inside their pipeline, tuned per account.
Jess is the setter. She runs on one canonical persona file so she can never contradict herself across channels, and she carries an absolute honesty rule: asked sincerely whether she is a person, she says she is an AI assistant, every time.
The persona is there to take the sales pressure out of a first message. If it ever left someone believing they had spoken to a person, it would have failed.
The orchestrator. Reads any incoming task, routes it to the right specialist, and owns the hand-offs between them.
Runs the morning sweep, drafts the daily brief, maintains per-client state and keeps the other agents honest about what happened overnight.
The human checkpoint. Owns an append-only approval queue that any specialist can write to and nothing ships past.
Writes every word a human outside the company reads. Ad copy, landing pages, nurture email, conversation scripts.
A binary gate between creative and deployment. Audits every outbound asset against compliance and brand rules, then returns pass or fail.
Turns a creative brief into finished production assets. Most of the work is in the generation prompts, which decide whether an image is usable or just decorative.
Runs the Meta campaigns: creative production, ad copy, state-by-state targeting, budget pacing and top-of-funnel testing.
Builds and deploys landing pages and resource hubs, from a single conversion page to a full Next.js hub.
Drafts client email in my voice, builds the narrative for performance reports, and carries onboarding follow-up.
Drives a real browser to test the whole funnel end to end: ad to landing page to CRM, verifying the conversation AI actually fires.
A router over four CRM specialists: one builds pipelines and workflows, one audits live state read-only, one deploys the conversation AI, one runs day-to-day ops. Fires into any of 23 client instances by slug.
Six agents that produce a 28-to-40 page evidence-backed buyer's guide: harvester, researcher, scribe, compositor, adversarial critic and citation librarian. Every claim traces to a fetched, verified source.
This is the live operations console, captured from the machine the platform was built on. Over seven days it routed 2.17 million tokens to local GPU inference instead of a metered cloud API, with model routing per task type, automatic context sizing and a savings ledger.
Bulk extraction, classification and summarization run on hardware I own, and the metered models are kept for the judgment calls. That gap is most of what separates using AI from engineering with it.
Live console, captured today. Left: resident models on a 16GB RTX 5070 Ti. Right: seven days of local inference broken out by lane, with the routing map beneath. Client identifiers and account spend redacted.
Wired into delivery, from creative QA to budget pacing.
Composable capabilities the agents call.
CRM, ad platforms, analytics, billing, storage.
One CRM per client, each with its own creative memory.
Routed by task: reasoning, extraction, vision, OCR, embeddings.
Compliance, brand and AI-detection, enforced in the pipeline.
Every static ad passes a locked final gate before it exists as a deliverable. A deterministic lint checks brand hex values, banned phrasing, duplicate copy, logo placement and client-data leakage. Anything that fails is automatically recreated and re-checked, looping until clean.
Quality at this volume cannot be a review step. It has to be a property of the pipeline.
A detection layer sits on every publish surface: ads, email, landing pages, ebooks, social. It flags AI writing tells and blocks the asset. A warning would just get waved through.
It was tuned the hard way. A false positive that stops a real campaign is worse than no rule, so every hard rule is blast-radius tested against live batches before it ships.
Almost everything below exists because something went wrong in front of a real customer, and the fix was a rail that makes that failure impossible to repeat. The rail became the product. Two of them are the same architecture arrived at twice: a model that forms the judgment, wired to code that holds all authority to act.
The screenshots are the running systems, captured 2026-08-18. Prospect names, client names, account identifiers and balances are redacted. The engineering is the story, not the balances.
The model is not allowed to place an order.
A local 14B model forms the thesis on a 15 to 30 second loop. Tick-driven code reads it as plain flags and holds every order.
The brain can only make the system more conservative. It never sizes, never fires, never overrides a guardrail.
62,613 lines of Python trading a real account. Default state: flat and idle.
The live dashboard. A hypothesis book, a conviction gauge, and a decision ticker that prints every abort with a reason. Account identifiers and balances redacted.
It trades QQQ 0DTE options, single-leg long only, on a cash account. There's no paper mode to hide behind. Account size is never hardcoded: every session starts from a live broker snapshot, so sizing follows the account with zero code edits.
The guardrails are the actual product. Trade-count and budget locks, a daily-loss halt, an equity-drawdown kill switch against a rolling high-water mark, a stale-data watchdog, and a global exception handler whose only move is flatten, halt, alert. There is no assignment code path at all, so a contract can never be carried into expiry.
Before deploy it ran an adversarial review with two named reviewer roles. Both blockers were fixed first, and the residual risks are written down instead of omitted.
One prospect got 10 outbound messages in a day, 7 of them inside 11 minutes. 44 of 76 sends came from us, composing by hand with no counter running.
Code decides who gets messaged and when. The model only drafts what's said, and a draft that fails a validator is discarded, not sent.
Count what the recipient received, from every source. Four earlier caps failed because each sender counted only its own sends.
Proactive cap: 2 a day, 5 a week, enforced at the contact. Booked meetings on the board every week.
The wall: every live thread ranked the way a real SDR would work it. The "Held by the touch guard" lines are the point. Prospect names, numbers and companies redacted.
An always-on setter. It watches every inbound lead, decides who needs a touch and when, drafts the message, validates it, sends it, and runs a deterministic post-booking playbook that no inbound text can prompt-inject.
It carries an absolute honesty rule: asked sincerely whether she's a person, Jess says she's an AI assistant, every time. The persona takes the sales pressure out of a first message. It never exists to make someone think they're talking to a human.
The board keys one company to one prospect by email domain, so two people at the same pharmacy never get worked as separate leads. Booking state only moves forward: a later sweep can never un-book somebody.
These two were built months apart, for unrelated purposes, and landed on the same architecture without either copying the other. In the setter, the model drafts a sentence and code decides who receives it. In the trader, the model forms a thesis and code decides whether money moves. Both state the constraint identically: the model can only make the system more conservative, never less safe. That's a held principle showing up twice, not a trick reused.
Sales coaching arrives after the deal is already lost. And every AI notetaker ships the audio to a vendor, which is a non-starter in healthcare.
Speech runs locally on the rep's own machine. Six discovery questions tick green as the prospect answers them, hands never touching the keyboard.
Quote a price before the six are answered and the whole screen goes red.
The coaching rules came out of 40-plus recorded calls. $49 a month, one double-click Windows install.
The console between calls. Six questions lock the price, the talk-ratio bar wants the prospect above 60%, and the right rail is the close ladder.
It also watches your talk ratio, arms a silence watchdog the moment you ask for money, and writes complete notes to the right CRM contact when the call ends. A training room throws real objections at you out loud and grades what you actually said.
Every tool disagreed with every other tool, so nobody trusted any of them, so decisions got made on feel.
One cockpit: 95,766 lines, 145 API routes, 18 surfaces, and a 10,482-line finance library whose only job is making one number correct.
Render is not push. Every ad is born paused. Push is a human action, per client, every time.
9 of 9 labs ready, 225 of 225 ads through the pipeline, in the capture below.
The build surface. 9/9 fleets ready, 225/225 ads, and the push control reads "born PAUSED" in the corner. Client names replaced with numbered labels.
Creative production, Meta push, finance truth, fleet health, goals, performance and the Jess board, all in one Next.js app that's load-bearing daily. The ad pipeline is a locked, documented path: nobody writes a one-off driver script, and the last node before Meta is a human.
Image models misspell logos, duplicate words and leak prompt text into the art. At batch scale a human reviewer misses about half of it.
Three stacked gates. The last one is shown the rendered ad and the real logo file together, and returns a strict verdict.
A hard fail refires the ad through its own batch script automatically, looping until clean. The gate exits clean or not at all.
10,509 ad variants across 60 accounts. Zero shipped with a misspelled logo.
Client logos are composited, never generated. Every rendered string is quoted in the prompt, because an unquoted line is an invitation for the model to invent its own words. And the gate is deliberately lenient where strictness would be wrong: a false positive that blocks real work is worse than no gate.
The finished output is in the output section: the ad wall and the lead magnets on this page all came through these gates.
Prospects read decks alone, do the arithmetic against your price, and talk themselves out before the call.
17 cards at one URL, keyboard and swipe navigable, films playing inline, with per-card analytics and an ROI slider that uses their inputs.
No pricing on it, and never show net beside gross. If both are on screen they subtract, and the subtraction is your fee.
One link replaced the slide deck, the portal and the leave-behind. It's the only deck link a prospect ever gets.
Card 01 of 17. A break-even slide was built, then deliberately deleted: some slides lose deals by being honest in the wrong order.
36 mountain-town markets, each anchored to a real town and one plain-English rule implemented server-side: about twenty minutes to a supermarket. Every hit was scored for under-market dollars per acre against that area's own rolling history, because a per-acre number means nothing against a national average.
A full sweep across all areas cost under a dollar, at roughly $0.0009 per listing. The rolling ledger holds 2,206 listings, deduplicated so the same parcel never alerts twice.
Written in the past tense on purpose: the last run failed on all 35 areas it attempted, so the qualifying counts are carried forward from earlier successful runs. The card gets its present tense back when the run does. A file existing is not proof, including our own.
A multi-tenant coaching platform for an external client, 12,417 lines, live on Vercel. The client's database didn't exist yet and the demo couldn't wait, so with zero environment variables it boots on seeded data and every screen works. Same components, one data-source switch. It demoed real on day one and became production without a rewrite.
Authorization lives in Postgres row-level security, not in application code. The app never decides access. Phosphor-terminal design language: one accent, mono for every number, command palette on Cmd+K.
31 jobs across six phases, nightly, on my own GPU. Episodic memory, a concept graph, and a priming cache that gets session start under 100ms. Token cost: $0.00.
Five gates that each make a specific past failure impossible to repeat. Every rail has a date on it, and the date is the day it cost something.
A 33,065-line MCP server with about 285 tools, mounted ten times, once per client account. The difference between an agent that can read a CRM and one that can run a fleet.
10,482 lines whose only job is one correct number. Two processor keys once doubled revenue, and a half-loaded ledger once printed a -206% margin. Truth needs a definition, not a SUM.
Co-branded dashboards with 180 days of daily history, refreshed nightly. Lead counts verified digit for digit against the ad platform's own reporting UI, because a dashboard that's slightly off poisons every number on it.
14 pipeline versions. One reference build cut 10 ads from a client's real footage: 227 cuts, zero repeated shots. The logo is composited from the real file, never generated.
The whole funnel running unattended. Its best output was a diagnosis: 81.8% of booked calls showed up and 4.4% closed. Two numbers, one conclusion, and it pointed at the human on the call.
Ebooks and lifecycle email produced by pipeline under one standard: a hard content gate runs before any image budget is spent, so a bad draft can't cost money.
Everything in the 48 hours around a sales call: reminders in the prospect's real timezone, a watch signal to the ad platform, transcript capture after. Rule learned live: a pre-call text never pre-qualifies.
An offline-first sales training PWA with audio lessons, built to work on a flight. A phone can't play media from a file path, so it had to be a real installed app.
The 4,170-line wall the setter is judged on: four outbound systems side by side rather than merged, because they fail differently and a merged view hides which one is broken.
Twelve small apps that stayed small: a deal desk, a review app, a pricing calculator, a launch page. Most could've been a platform. None should have been.
Every account runs to a fixed funnel mix. The distribution is set in advance, the offer stack comes from that client's own verified strengths, and each stage gets its own creative treatment, because a scroll-stopper and a closing offer are not the same photograph.
Awareness. Carries the audience tag in the picture, unmissable: "for Miami GPs", "for full-arch dentists". If a viewer cannot tell in a third of a second that the ad is for them, they scroll. Documentary treatment, because polish reads as an ad.
Consideration. Pillar-specific and territory-specific. Clinical product photography and macro detail, because precision at this stage has to be visible in the photograph itself. No audience tag.
The direct offer. A warm face plus a credibility object. This is the only stage where the number leads, and only when the number genuinely is the outcome.
The free tool, the buyer's guide, the review builder. Real utility that earns the click before anything is asked for, produced by the research pipeline so every claim traces to a source.
Every client gets their own CRM instance built from a versioned snapshot: pipelines, stages, workflows, custom fields and values, calendars. One standard layout, deployed by slug, which turns standing up a new account into a build script.
Stages advance on tag or on time, so the pipeline reflects reality without anyone dragging cards. Retention and referral are stages in the pipeline, not an afterthought, which is what makes reactivation systematic instead of a quarterly panic.
Every build runs a pre-flight first: confirm the account exists, confirm the credential can reach it, and read that client's specific restrictions. Only then does a build start.
Then the hard rules. Never rename a pipeline on a live account, because a rename orphans every open opportunity. Never delete a stage that has deals in it. Never skip capturing stage IDs, because workflows reference them and rebuilding re-rolls them.
Automation against production data is only worth having if it refuses to do the thing that quietly destroys a quarter of pipeline.
A full-year nurture sequence per brand. It reads as one continuous story, with branch points for people who go quiet and separate recovery paths when something breaks.
The conversation AI picks up from there inside the CRM, so a reply never lands in an inbox nobody is watching.
Buzzword's own acquisition runs through the identical pipeline: the same funnel mix, the same creative gates, the same CRM standard. The ads on this page are ours, not a client's.
Running our own demand generation on the system we sell is how we find out what breaks before a client does. Every improvement gets tested here first.
A delivery system is worth whatever it ships. These are finished, shipped assets, produced through the pipeline with brand rules, compliance gates and an automated QA pass applied before anything reached a client.




Lead magnets and long-form. Researched, written, illustrated and typeset by the Factory, then gated for claim safety. Every factual claim traces to a source that was actually fetched and read.



Positioning, messaging, paid social, lifecycle, content and creative strategy across 21 accounts and four brands. $800K+ in annual media under management.
Built the outbound motion and the offer, and closed the deals myself. Regional exclusivity across roughly 100 US territories. Previously added $500K+ to pipeline in under three months as an SDR at Carbon.
Hired and lead eight across account management, paid media, CRM engineering and social. Set the operating cadence and the quality bar, and decided what escalates to me.
Own the P&L, pricing, margin and forecasting. Built the finance cockpit that reconciles revenue, spend, payroll and churn without a bookkeeper in the loop.
Designed the delivery system itself: intake, production, QA, approval, reporting. The reason 21 accounts run on eight people.
Wrote the platform. Node, Python, Next.js, Postgres, local and hosted LLMs, MCP servers, browser automation and evaluation harnesses.
Buzzword Strategies LLC
Carbon, Inc. · digital manufacturing
Carbon, Inc.
Partners Dental Studio
VP of AI, Head of AI, AI in marketing, or a CMO seat at a company that wants an operator who ships. Fully remote. Buzzword is built to be sold and the platform runs delivery without me day to day, which is exactly why I'm looking.