Buying seats is the easy half. The hard half is context: what each person knows, how each workflow actually runs, and where the handoffs sit. Someone has to move all of that into a form a model can reuse. That is the job I do.
Every team I have worked in hit the same wall. Good people, good tools, and knowledge that never left anyone’s head. A model works with what it is handed. Hand it a blank prompt box and it hands back generic work.
The wall is an ownership problem. Buying licences is procurement. Turning know-how into reusable context, and turning processes into workflows a model can run twice the same way, is a build job. Someone has to hold it, inside the stack, with the authority to change how the team works.
I hold that job. Ten years of running marketing programs taught me where the work actually breaks. Writing the code myself is what lets me fix it at the layer where it breaks.
The layers stack, and each one needs the one below it. The knowledge base feeds the agent teams, governance is what makes their output safe to ship, and only then is it sane to let agents deal with each other across seats.
What every person knows, written where a model can load it.
Without it, prompts carry the context and nothing accumulates. 02Each seat rebuilt as an agent with its own context, skills and queue.
Without it, output varies run to run and nobody can trace it. 03One control plane, declared tool access, and gates a person holds.
Without it, legal and finance treat the whole thing as unusable. 04Agents that answer each other, so a handoff stops needing a human.
Without it, everyone has a private copilot and still relays by hand.Without this layer a company runs on tribal memory. The person who knows why a claim is risky sits three desks away, and the model never meets them. Every answer arrives plausible and shallow.
With it, the knowledge becomes an input. Brand voice, product capability, the regulator’s rulebook and last week’s decisions all live as files an agent loads before it writes a word. Quality stops depending on who is at the keyboard.
I build context from primary sources rather than summaries. My weekly compile reads nine channels plus that week’s agent-chat history, because a large share of my real progress exists only inside those sessions. It writes two records: one a person scans, and one an agent queries. The second accumulates into a knowledge base, and both layers above depend on it existing.
9 channels + agent-chat history → 2 records, one of them built for machinesWithout this layer, AI output is a lucky draft. It reads well, it cites nothing, and nobody can tell you which step produced the error. Teams that touch money or brand cannot ship on that basis, so they quietly stop using the tool.
With it, a run has stages, budgets and hard stops. Revision loops get a fixed budget so nothing churns forever. A claim without a source is a must-fix. Outputs are schema-validated, runs are archived, and publishing always waits for a person.
The guardrails matter more than the models. In one archived round, ten proposed system changes came back nine adopted, one revised, none rejected, and every proposal had to cite a documented failure rather than sound plausible. The one sent back wanted a late rewrite pass that would have run after the fact-check gate.
Bounded loops · frozen judges · a human on anything irreversibleThis is the layer people skip, and it is the one that kills the programme. A team that touches money or brand cannot put unreviewed model output in front of a customer. Without somewhere to point when legal asks how a claim got approved, the honest answer is that nobody knows, and the tool quietly stops being used.
So behaviour lives in one place rather than inside prompt strings scattered through code. Every system prompt sits in a console, bound to a named model, declaring which tools it may call and which servers it may reach. Changing what an agent does becomes a configuration change with an audit trail.
The gates matter as much as the console. Review personas are frozen and may only get stricter, so an improvement has to come from the generating side. Scores read as diagnostics and are never the target, because a system optimised against its own judge converges on flattering the judge. Every proposed change must cite a documented failure. Anything irreversible waits for a person.
35 system prompts in one console · declared tool and server access · audit trail on every changeWithout this layer, every person has a private copilot and the org chart still runs on interruptions. A manager asks, someone context-switches, digs, replies, then gets the follow-up. One real question costs two rounds and a day.
With it, the handoff moves down a level. When my agent finishes something another project depends on, it pushes that to the dependent party’s agent as a notification. When someone needs detail about my work, their agent queries mine, and mine finds the answer in the sources it already reads. Only the genuinely hard problems reach the two humans.
I designed this from both seats. I built the compile layer, and my manager built the consolidation layer above it, pointed straight at the two records mine produces. Each person publishes wherever they already work, so nobody migrates tools to join the model. I am piloting the direct agent-to-agent path now as the Answer Desk.
Push a finished dependency · pull an answer · escalate only the hard problemsThe first version has to be one I pay for when it breaks. That keeps it honest, and it gives the next person a working example instead of a proposal.
I take the work I already do, put it behind an agent, wire in my own channels and archive every run. The first version has to be one I pay for when it breaks, which is what keeps it honest.
my own week
A workflow only travels when the knowledge behind it is written down. Personas, brand rules, module constraints and last week’s decisions become files, and the drill-down record accumulates into something another agent can query.
skills as files
Every system started as a pain I had already paid for: ad copy dying in policy review, leads going cold over a twelve-hour handoff, a monthly close eating an afternoon. No number on the pain, no build.
a number attached
A tool outside the stack is a demo. The ones that earned their place went into 200+ workflows across an eight-tool stack, and lead handoff fell from about twelve hours to one or two minutes.
wired in, not bolted on
I hand the next person a working example and the skills that run it. Their job becomes their own workflow, with their own agent holding their context, and the team’s work turns into improving how those agents cooperate.
seat by seat
Each one started as a job I was doing badly by hand. Same three layers at product scale: a rulebook or a catalog as context, a bounded pipeline as the workflow, and a person holding the gate. Every one is live on a public URL.
React
TypeScript
Vite
Tailwind
Gemini 2.5 FlashLearns your brand voice from your own site, writes channel-native copy for Google, Meta, LinkedIn and Bing, and audits every line against platform policy and your own rules as it writes.
ReactTypeScriptViteTailwindGemini FlashPaste a fintech marketing draft, pick the jurisdiction, and get a severity-ranked audit: every risky phrase quoted and matched to the FINRA 2210 clause it trips.
ReactTypeScriptViteTailwindHeadline, body, URL and the creative itself, audited against ~84 embedded platform policy clauses plus your saved company rules. You get a safety score with every risk explained, before upload.
ReactTypeScriptVite
Neon PostgresGemini 2.5 Flash
ResendPaste a Douyin or TikTok profile and it collects the catalog, lifts the transcript from every video, translates and rewrites on your own prompt, then exports to Excel. Runs on the user's own session rather than a shared account pool, which is what keeps accounts safe.
React 19TypeScriptVite
PrismaGemini 2.5
GPT-4o · WhisperOne pasted job description becomes a tracked application, a resume run through a six-step tailoring engine with its ATS read-out, and interview prep built from the same context.
React 19TypeScriptViteNeon PostgresGemini 2.5 FlashAn ETL pipeline scrapes the catalog, strips and transcribes the audio, and embeds everything into a vector store, a Digital Brain you query instead of three hours of scrolling.
React 19TypeScriptFingerprints the HTML and JS bundles, reads DNS and email posture, maps subdomains, then renders the site in a real browser for a deep scan. Every finding is evidence-backed.
Meta Graph API
Ads TransparencyCollects a rival's public ad library, enriches every creative and landing page, labels the set with AI behind a human review queue, and returns a campaign anatomy: market, message, spend posture.
The case studies show the method running inside a company, with other people in the loop. The writing shows the reasoning before the result was known, which is the harder thing to fake.
The machinery exists as archived runs and human-gated proposals in a real repository. The lift is internal so far, and I would rather leave a cell blank than invent a figure.
The numbers with other people in the loop are the ones from programs I ran: a revenue line from $2M to $250M+, lead handoff from roughly twelve hours to one or two minutes, and a monthly close from one to two hours down to under five minutes.
There is no external before-and-after on the agent machinery. The share of my week it handles is my own estimate and is labelled as one wherever it appears. Layer 3 is a pilot, and it says so on every page that mentions it.
Personas are markdown and the rubric is one file, so the same machinery retunes to a new team by editing text rather than rebuilding.