Building an agent, the BlitzMetrics way, means documenting a task to a standard so complete that a human or an AI can run it identically — same trigger, same steps, same definition of done. We build agents now because models finally persist: they loop until the work passes QA, hold memory across runs, and improve themselves, so every task you document stops being a wiki page and becomes a worker.

That definition is the whole page in two sentences. What follows is how we build agents, how we equip them, and — the part almost everyone skips — how we keep them current as Claude, Gemini, and OpenAI’s models leap forward every few months. This page is the philosophy and the system. The inventory itself lives on the Task Library Dashboard, and we’ll get there.

What an agent actually is here

Not a dashboard demo. Not a chatbot wrapper. At BlitzMetrics, an agent is a task documented to the definitive article standard with a companion skill.md — a machine-readable SOP that carries:

Frontmatter — permanent name, category, Content Factory stage, the definitive article it implements, and an honest status.
“Use this when” — the trigger, in one line.
Inputs — everything needed before starting. No hidden prerequisites.
Steps — the real process, imperative and concrete.
Definition of done — an objective QA checklist, not “make it good.”
Example and links — at least one documented real run, plus links up to its hub article and across to sibling skills.

Hand that file to a new team member and they can run the task. Hand it to an AI agent and it runs the task the same way. The instructions outrank the operator — which is exactly what makes the output consistent. One documented task is an agent. A library of them is a workforce. Ours runs the Content Factory — Produce, Process, Post, Promote — the engine that turns one real recording into articles, clips, and ads.

The proof: 239 tasks you can browse and download

We didn’t write the philosophy first and hope. We documented our entire operation: 239 tasks across 13 categories — from digital plumbing to Dollar a Day to website QA — mapping to 22 definitive articles. As of this writing, 119 are complete, 97 need work, and 23 are gaps. Those statuses are public on purpose: an honest scoreboard is what makes a library improvable, and every red gap is a work order, not an embarrassment.

All of it is live on the Task Library Dashboard: search the full SOP text, read any skill, copy it, or download all 239 in one free zip. The dashboard is the what. This page is the how and the why. And the build story — how parallel AI workers brought all 239 tasks to standard in a single day — is documented in its own meta-article: How We Turned 239 Tasks Into an AI-Runnable Skill Library.

How we build an agent: the loop

Every agent in the library comes from the same five-beat loop:

Do. Run the task for real. You can’t document what you haven’t done — steps written from imagination produce agents that fail in production.
Document. Write the skill.md to the standard above. The steps mirror what you actually did, not what you aspire to do.
QA. Grade the file against its own Definition of done, line by line. If reasonable people could argue about whether the task is finished, the checklist isn’t done.
Example. Publish a meta-article documenting one real run — proof, not promises — linked back to the skill and its hub.
Improve. Feed what the run taught you back into the skill, following the update protocol in Knowledge System Maintenance. The next run starts from a better document.

Then it repeats — and here is the compounding part: agents now run the loop on themselves. Each run documents itself, QAs itself, and proposes its own improvements. We call this recursive self-improvement, and it is why the library gets sharper every week instead of staler.

Done right, documentation isn’t a record of the work. It is the work — and it does the next round on its own.

How we keep agents current

This is the section that separates a living system from a folder of dead SOPs. The models running these skills improve every few months, and every improvement changes what “done” can mean. So we continuously update our skill files and agents to take advantage of the newest capabilities — Claude (including Fable 5’s persistence, looping, and memory), Google Gemini, OpenAI’s models, and whatever ships next. When a frontier capability lands, we don’t admire it. We re-equip the library.

What changed in the models	What we changed in the agents
Long-horizon persistence	Agents loop until the Definition of done passes. Ninety percent finished is a draft, not a deliverable.
Memory across runs	Skills instruct the agent to read prior runs and upstream outputs first. Never start from scratch twice.
Self-verification	The agent grades its own output against the skill’s QA checklist, line by line, before reporting done.
Near-zero cost of completeness	Full coverage by default: edge cases, error paths, the test, the doc — the whole thing.

That last row has a name. Garry Tan’s essay “Boil the Ocean” calls the turn: “don’t boil the ocean” was good advice when implementation was expensive, and it is obsolete now that AI compresses implementation 10–100x. Our version of the rule: with AI, the marginal cost of completeness is near zero — so do the whole thing, do it right, and ship the finished product, not a plan. We installed that as a literal operating layer in the library — a principles file every agent reads before running any skill, governing how all of them execute.

And because “we keep agents current” is a claim anyone can make, we date everything. Every update is logged, every run leaves a meta-article, and the dashboard carries the changelog. The proof of currency is a paper trail, not a promise.

From skills to a workforce that earns

Here is where this goes, and why it is worth the discipline. Your expertise today is tribal knowledge — it lives in your head and your best people’s heads, and it leaves when they do. Documented to this standard, it becomes skills. Skills become agents. Agents deploy first on your own client work — every audit, every campaign, every report running at senior-operator quality — then beyond your shop, into marketplaces where agents running your documented expertise serve businesses you have never met. The end state: your documented knowledge working, and eventually earning, without you in the room.

This is positive-sum, and I want to be precise about that. When intelligence gets cheap, the work doesn’t shrink — the amount of work worth doing explodes. Operators we work with, like Marko Sipila at HVAC Quote and Zach Peyton at Superior Fence & Rail, were never short on demand; they were short on trained people. Agents give a first-year apprentice the checklists that used to take a decade to earn, and the human graduates to judgment — choosing the goals, calling what’s true, and deciding what gets amplified. That is the engine behind my mission of creating a million jobs: not the same work with fewer people, but far more work with more people, each one operating at a higher level.

A worked example: DealCon

One hands-on application, so you can see the system land. At the DealCon workshop, every attendee scans a QR code at dennisyu.com/dealcon and installs a 10-skill personal-brand system — strategist, proof harvester, Knowledge Panel plumbing, Dollar a Day, Content Factory, recursive QA — on their own Claude in about 60 seconds. Every one of those skills is built to the exact standard on this page and kept current for the latest persistent agents.

DealCon is one room. The system is for everyone: agencies documenting delivery, contractors documenting estimates and follow-up, founders documenting the sales motion only they know how to run. Same standard, your tasks.

How to start

Pick one repeatable task. Your most frequent, not your hardest.
Document it to the standard — frontmatter, trigger, inputs, steps that mirror reality.
Add a Definition of done. Objective and checkable, so the agent can grade itself.
Run it on a persistent agent. Let it loop until the checklist passes.
Log a meta-article of the run as the skill’s first example.
Improve the skill from what the run taught you. Then pick the next task.

Ten cycles in, you will feel the compounding. And you don’t have to start from a blank page: go to the Task Library Dashboard, browse all 239 skills, download the whole library free, and read the definitive article guide to write skill number one for your own operation.

Document the task. Equip the agent. Keep it current. That is the whole system.

How BlitzMetrics Builds AI Agents — and Keeps Them Current