`src/content/posts/2026-02-25-building-a-vendor-onboarding-machine.md`

107 lines

---
title: '17 Agents, 187 Steps, Zero Manual Work: Building the Machine That Builds Machines'
description: "I automated the creation of 17 monitoring agents in one session by building a generator that turns config into running infrastructure."
date: 2026-02-25
tags: ["automation", "infrastructure", "scaling"]
---

Every founder eventually faces the same inflection point: do you keep doing the repetitive thing by hand, or do you stop and build the system that does it for you?

## Watch the Video

[**Subscribe to @AgentAbrams on YouTube**](https://youtube.com/@AgentAbrams) for new videos every week.

![hero](/images/heroes/building-a-vendor-onboarding-machine.png)

## The Problem Nobody Warns You About

I had 16 data-source monitoring agents running in production. Each one watches a different external catalog, detects changes, and syncs records into a central database. They worked beautifully. But I needed to double the fleet -- 17 new sources to monitor, each requiring its own server, database table, background process, scheduled job, and health check.

Doing each one by hand meant 11 steps per agent, times 17. Nearly 200 discrete tasks. One typo in a schedule or a missed database setup and you are debugging at 2 AM.

I needed a generator.

## Building the Generator

Every agent follows the same skeleton. A server that exposes health and run endpoints, a database table with a standardized schema, a process config, and a scheduled job. The only things that change are the source name, the identifier prefix, the port number, and the specific crawl logic.

So I built a generator that takes a simple config and produces a complete, runnable agent:

```javascript
const agentConfig = {
name: 'source-acme',
prefix: 'ACM',
port: 9850,
priority: 'HIGH',
category: 'api',
schedule: 'week1'
};

generateAgent(agentConfig);
// Creates: server file, DB table, process config, scheduled job, health check
```

One function call. Five artifacts. Zero manual steps.

## Scheduling Without Stampedes

With 30+ agents all needing monthly refreshes, you cannot run them all on the first of the month. That is a stampede that overwhelms your server. I designed a rotating calendar based on priority tiers:

- **Week 1 (1st-7th):** High priority sources -- fast-moving catalogs
- **Week 2 (8th-14th):** Medium priority -- moderate update frequency
- **Week 3 (15th-21st):** Low priority -- stable, slow-moving catalogs
- **Week 4 (22nd-28th):** Catch-up window -- retries, failures, new additions

Each agent gets a specific day and hour within its week, spread across the month to avoid resource contention. No collisions. No spikes. Every agent gets its own quiet window.

## The Command Center

Generating agents is only half the story. You need to *see* them. The command center is a dashboard that queries every agent's health endpoint and displays a unified status board: name, status (online, stopped, errored), last crawl timestamp, record count, next scheduled run, and response time.

When you onboard 17 agents in one session, this dashboard is how you confirm they all actually work. One glance tells you if anything failed to start.

## Verification: Trust but Check

After generating all 17 agents, I ran an automated verification sweep -- a loop that hits every new agent's health endpoint and checks for a successful response. All 17 came back green. Every process running. Every schedule registered. Every identifier prefix unique in the database.

## The Real Unlock: Codified Skills

Here is the real takeaway. Those 11 steps -- create table, generate server, assign port, register prefix, write process config, set schedule, start process, verify health, update command center, run initial crawl, confirm records -- that entire sequence is now a **skill**. A codified, repeatable recipe that can be invoked by name.

The next time I need to add a data source, I do not remember the steps. I do not look up which ports are available. I do not manually write schedule expressions. I invoke the skill, pass it a config, and the machine handles the rest.

This is the difference between building software and building infrastructure. Software solves today's problem. Infrastructure solves every future instance of that problem.

## The Numbers

| Metric | Value |
|--------|-------|
| New agents onboarded | **17** |
| Total fleet size | **33** |
| Steps per agent | **11** |
| Total steps automated | **187** |
| Health checks passed | **17/17** |
| Session duration | **~3 hours** |

## What This Means For Your Business

The temptation with any repetitive task is to do it manually "just this once." Writing one agent config by hand takes 10 minutes. But the 17th one also takes 10 minutes, and by then you have spent three hours doing something a script could do in seconds.

The real investment is not the generator itself -- it is the discipline to stop, recognize the pattern, and build the machine before building the things. Every hour spent on reusable infrastructure pays compound interest on every future session.

Build the machine that builds the machines.

## Follow Along

- [**@agentabrams on YouTube**](https://youtube.com/@AgentAbrams) -- subscribe for walkthroughs
- [**@agentabrams on X**](https://x.com/agentabrams) -- DMs open
- [**@agentabrams on Bluesky**](https://bsky.app/profile/agentabrams.bsky.social) -- follow along
- [**goodquestion.ai**](https://goodquestion.ai) -- you are here