Scope it, spec it, deploy it, and let it graduate. Agent Architect runs any agent idea through a hiring pipeline with a quality gate at every stage, so it ships small and earns its autonomy over time.
← All Claude SkillsMost agent ideas die two ways: scoped so big they never ship, or shipped so loose they fail silently for weeks. This skill fixes both. It walks your idea through a roster, a scoping standard, a one-page build spec, a deploy, an on-ramp, and a graduation, so the agent earns trust before it earns autonomy. Copy the two blocks below and give them to your Claude.
Step 1. Copy the skill block below.
Step 2. Open Claude and paste this instruction first, then paste the block underneath it:
Turn the block below into a Claude skill and install it. Create the skill file exactly as written. Then personalize it with smart defaults from what you know about me: my business, my voice, my current priorities, and where I keep my work. Confirm when it is installed and tell me how to run it.
---
name: agent-architect
description: Design, scope, deploy, and graduate AI agents and automated routines using a hiring standard that puts a quality gate at every stage. Use this skill whenever you say "design an agent," "agent architect," "run agent architect," "hire an agent," "spec this agent," "I want an agent that...," "automate this role," or want to turn a recurring duty into a scoped, deployed, trustworthy automated routine. Also trigger when you have an agent idea that feels too big, an automation that silently failed, or a roster of agent ideas with nothing actually running. This is the bridge between "I want AI doing this for me" and a deployed agent that earned its autonomy through a graduation process.
---
# Agent Architect
Hiring an agent is hiring. Treat it with the same seriousness a good hire gets, and it pays you back the same way. This skill runs any agent idea through a hiring pipeline with a quality gate at each stage, so the agent ships scoped and earns its autonomy over time.
## The Big Idea
Most agent projects die one of two deaths: scoped so big they never ship, or shipped so loose they fail silently until someone notices weeks later. The fix is a hiring pipeline with a quality gate at each end. An agent earns its job through a Build Spec, earns trust through an On-Ramp, and earns autonomy through graduation. Nothing skips a stage.
**The pipeline:** Roster → Scoping Standard → Build Spec → Deploy → On-Ramp → Graduation → Ownership Flip.
## Stage 1: The Roster (hire for the gap)
Keep one canonical roster of every agent: running, designed, and imagined. Each row carries a name, a status (Concept → Designed → Building → On-Ramp → Active → Paused), and the business gap it closes.
The hiring trigger is a named leak or a named gap, never a cool demo. "Money walks out of the pipeline because follow-up lives in my memory" hires an agent. "It would be neat if AI did X" does not. If you cannot name what the agent's absence costs, you are not ready to hire it yet.
## Stage 2: The Scoping Standard (seven rules, all of them)
Every agent gets scoped against these rules before any building happens:
1. **One duty.** Version 1 does exactly one job. Future duties get listed under "v2 and Beyond" and wait until the first duty graduates. An agent with three duties is three agents wearing a coat.
2. **Scheduled, never continuous.** The agent runs on a clock (daily at 5:15 AM, weekly Mondays), does its job, and stops. Always-on agents are debugging nightmares and cost leaks.
3. **Cheapest passing model.** Start with the cheapest model that passes review for the work type. Drop a tier only when review stays clean. Frontier models design the agent, cheaper models run it forever.
4. **Bounded sources.** The agent reads from an explicit, finite list of sources and nothing else. Name every database, API, and document. Unbounded reading is unbounded risk.
5. **Memory loop.** Every run starts by reading the standing memory entries (corrections, rules, patterns from past runs) and ends by writing one observation. Agents that cannot remember corrections repeat them forever.
6. **Failure protocol: loud beats silent.** A blocked run writes a blocker report naming the source, the error, and the timestamp, where you will see it the next morning. One retry with backoff, then stop. The cautionary tale: an agent that died of an expired auth token and nobody knew for weeks.
7. **Graduation criteria written before deployment.** Define what "trustworthy" means in observable terms before the first run, so trust is earned against a written standard you set down first.
## Stage 3: The Build Spec
One page, written before any code. Sections, in order:
- **Role.** The job in two sentences, including what stops leaking when this works.
- **Single Duty (v1).** The one job as a numbered run order, ending with what the agent does NOT do ("Stop. Nothing sends.").
- **Trigger.** The schedule, in your timezone.
- **Reads From.** The bounded source list.
- **Writes To.** Every destination, including the memory entry.
- **Handoff.** What you own. If output reaches the outside world (sends, publishes, charges), you own that step until graduation says otherwise. Drafts stage for review, the agent never touches the send button in v1.
- **Model and Home.** The model tier and where the agent physically runs (a cloud automation platform, a scheduled task on your own machine, and so on), with the honest constraints of that home stated (a laptop-bound routine needs the laptop open).
- **Failure Protocol.** Rule 6 made specific to this agent's sources.
- **Prerequisites Before Deployment.** The hard blockers, named. If a prerequisite is missing, the agent can still deploy in fail-loud mode: every run reports the missing prerequisite until it exists. A loud gate beats a delayed build.
- **On-Ramp Plan.** See Stage 4.
- **Graduation Criteria.** See Stage 5.
- **v2 and Beyond.** Everything you resisted putting in v1, parked.
## Stage 4: Deploy + On-Ramp (the quality gate between built and trusted)
Deploy on your green light. Then run a structured testing window (default 7 days for daily routines, 3 to 4 runs for weekly ones):
- The agent runs on its real schedule against real data.
- Each run gets verified by you against reality and logged clean, intervened, or wrong.
- Every output carries an On-Ramp label so nobody treats unverified output as gospel.
- The agent registers in a routine registry you keep (name, layer, schedule, status, last run) the day it deploys.
A failed On-Ramp gets a root-cause diagnosis, a fix, and a fresh clock. Only extend trust to an agent that has earned it on schedule.
## Stage 5: Graduation + Ownership Flip
Graduation criteria follow the pattern: **N clean runs, zero manual intervention, and outputs that pass review without revision twice in a row.** On graduation:
1. The registry row flips to Active.
2. The ownership flip completes: the duty's owner of record changes from you to the agent, and your job becomes reviewing the agent's output while it does the work.
3. The next duty (from v2 and Beyond) becomes eligible for its own pipeline run.
The ownership flip is the whole point. An agent that runs but never takes ownership just added a supervision job.
## Worked Example 1: A Follow-Up Agent
The gap: roughly $250K of named pipeline value sitting stale because follow-up lived in your memory. The spec: one duty (a daily weekday sweep of your CRM for due follow-up touches against a written cadence standard, drafts staged for morning review, nothing sends). Bounded sources: the CRM, the cadence standard, the voice guide, the memory entries. It deployed honestly gated: a live probe proved the CRM's lifecycle stages did not exist yet, so the agent deployed in fail-loud mode, writing a blocker report naming the missing stages every morning until a short setup unblocked real sweeps. The dry sweep that proved the gate also surfaced the stale pipeline, which became its own revival campaign. The gate was a finding, never a failure.
## Worked Example 2: A Library-Integrity Agent
The gap: a large skill library with no integrity check, where "built" claims had already been caught false twice. The spec: one duty (a weekly sweep verifying every index row against the real file on disk, recommendations only, nothing merged or deleted). First supervised sweep: every artifact verified, a handful of hygiene findings, and one genuine conflict surfaced to you for a decision. Registered at On-Ramp with a short window. The lesson it proves: read-only agents with loud findings build trust fastest, and an agent that surfaces a conflict it could have silently "fixed" is an agent earning graduation.
## Voice and Delivery Notes
Write specs in plain language you can read in three minutes. Status words mean things: Designed is a document, Deployed is a schedule that fires, Active is a graduation that happened. Keep "built" claims tied to an artifact behind them. Receipts beat promises at every stage.
Claude reads the block, builds the skill file, and installs it. From then on, you just run the skill in any conversation. No folders to find, no code to write.
Every week you see what's working, build it live, and put it to work in your business.
Here's the shape of what this skill hands you when it runs. Copy it, use it, keep moving.
You don't need to hold any of this in your head. That's the skill's job. If you're curious what it's doing for you, here's the idea underneath it.
Hiring an agent is hiring. A good hire gets a role, a trial period, and a review before you hand over the keys. This skill gives an agent the same path. It earns its job through a build spec, earns trust through an on-ramp, and earns autonomy through graduation. Nothing skips a stage.
The trigger to build is a named leak or a named gap you can put a number on. If you cannot say what the agent's absence costs, it is not ready to hire yet.
Seven rules every agent passes before any building: one duty, a schedule, the cheapest passing model, bounded sources, a memory loop, a loud failure protocol, and graduation criteria written first.
One page you can read in three minutes. Role, single duty, trigger, sources, handoff, failure protocol, and what the agent does NOT do. Written before any code.
A structured testing window where the agent runs on its real schedule against real data and you verify every output. This is the quality gate between built and trusted.
On graduation the duty changes hands. The agent becomes owner of record and your job becomes reviewing its work. That flip is the whole point.
The Scoping Standard is the set of seven rules every agent passes before any building starts: one duty, scheduled runs, the cheapest passing model, bounded sources, a memory loop, a loud failure protocol, and graduation criteria written first. It keeps an agent small enough to ship and safe enough to trust.
The Ownership Flip is the moment an agent graduates and the duty's owner of record changes from you to the agent. Your job becomes reviewing its output while the agent does the work. An agent that runs but never takes ownership just added a supervision job, so the flip is the whole point.
The On-Ramp is a structured testing window, seven days for a daily routine or a few runs for a weekly one, where the agent runs on its real schedule against real data and you verify every output. It is the quality gate between built and trusted, so an agent earns its autonomy against an observable standard.