Building an AI Agency from Scratch

Most people building with AI right now are focused on a single thing: making one task faster. Summarize this document. Draft that email. Generate a landing page. And that's fine. But it's not what I'm doing.

I'm building an entire consulting practice where AI agents are the team.

Not a chatbot. Not an assistant. A coordinated group of specialized agents that scope projects, create design specs, write content, build websites, manage DNS, deploy to production, and handle client onboarding. Each one has a designation, a role, and a job to do. They share data. They hand off work. They ship.

This is the story of how I built it, what the architecture looks like, and why I think it's the future of solo consulting.

The Problem with Being Solo

I spent ten years at agencies. I know what a functioning team looks like: a strategist who scopes the work, a designer who creates the visuals, a developer who builds the thing, and an account manager who keeps the client informed. That's four people minimum, and usually more.

When you go solo, you are all four people. You scope the project over coffee, switch to Figma for the design, open VS Code for the build, then write the client update at midnight. Context-switching is the tax you pay for independence.

I wanted to eliminate that tax. Not by hiring humans I can't afford yet, but by building agents that can carry their own weight.

The Core Four

The agency runs on four primary agents. Each one is a Claude Code skill with its own knowledge base, templates, reference materials, and tool access. They're not generic assistants. They're specialists.

General Manager (LM-000)

The GM is the orchestrator. Strategy, sales, finance, client management, and operational decisions all funnel through this agent. It writes proposals, scopes projects, tracks revenue, and decides which agents get deployed on a given engagement. When a new client inquiry comes in, the GM qualifies it, drafts the SOW, and kicks off onboarding.

Think of it as the senior partner who doesn't touch the tools but makes sure the right people are working on the right things.

Klaviyo Expert (LM-003)

Email marketing is one of my core service offerings, and this agent handles it end to end. Flow architecture, campaign strategy, HTML template creation, deliverability audits, segment analysis. It has direct access to the Klaviyo API through an MCP server, so it can pull real campaign data, create templates, and build draft campaigns without me copying and pasting between tools.

For one client, this agent audited their entire Klaviyo account, identified that they had zero flows and zero campaigns configured, and produced a complete 27-template design package with specs for every email in the lifecycle. That's not summarization. That's the work.

Designer (LM-004)

The Designer handles brand identity, creative briefs, and platform-aware design specifications. It knows the difference between an Instagram Story and a LinkedIn carousel. It produces specs that include exact dimensions, typography stacks, color values, spacing, and content zones for every deliverable.

It doesn't push pixels in Figma (yet). But it produces design packages detailed enough that any human designer — or a future image-generation agent — could execute them faithfully. The specs are the product.

Developer (LM-005)

The Developer builds and deploys. HTML, CSS, JavaScript, Tailwind, Cloudflare Pages, Workers, DNS configuration, SSL, email DNS records. It has MCP access to both Namecheap and Cloudflare, so it can check domain availability, configure nameservers, create DNS records, deploy to Pages, and verify SSL — all without leaving the conversation.

This is the agent that turns specs and content into a live website. It consumes the Designer's specs, the Copywriter's content, and ships the thing to production.

How They Coordinate

The real power isn't in any single agent. It's in how they pass work to each other.

Here's what a typical client website build looks like:

  CLIENT INQUIRY
       |
  [GM] Qualify lead, draft SOW, get signature
       |
  [Onboarding] Intake, collect assets/access, store credentials
       |
  [Designer] Brand onboarding --> creative brief --> design specs
       |
  [Copywriter] Voice profile --> content brief --> web copy, meta, alt text
       |
  [Developer] Consume specs + content --> build --> QA --> deploy
       |
  [GM] Review deployment, send delivery package, close project

Every agent reads and writes to a shared client directory. When the Onboarding Assistant finishes intake, it creates the client folder with contact info and asset access docs. The Designer picks up from there and adds brand guidelines. The Copywriter adds the voice profile and page content. The Developer consumes all of it and builds.

Nobody waits for a Slack message. Nobody asks "where's the brief?" The brief is in the shared directory, exactly where every agent knows to look.

The Supporting Cast

Beyond the core four, there are agents that handle the operational side of running a business.

The Onboarding Assistant manages client intake with gated workflows. It collects credentials, stores them securely in macOS Keychain, drafts service agreements, and runs readiness checks before handing off to the creative agents. No project starts until the contract is signed and access is granted.

The Copywriter is a content strategist that writes SEO articles, product descriptions, email copy, social captions, and landing page content. It follows the Brian Dean method — APP intros, bucket brigades, short paragraphs — and adapts to each client's voice profile.

The Research Assistant handles vendor research and outreach. It searches via Google Places, scrapes business data, qualifies prospects, and drafts personalized emails. It's the agent I deploy when a client needs to find suppliers, contractors, or venues.

Why This Actually Works

I get asked this a lot, usually with a skeptical eyebrow. "You're telling me an AI agent can do what a designer does?"

No. I'm telling you an AI agent can do what a designer does in the scoping and specification phase. It can produce a creative brief, define a brand system, and spec out every deliverable with enough detail to execute. The gap between spec and execution gets smaller every month.

But the real reason this works isn't about any individual agent's capability. It's about three things:

Specialized knowledge. Each agent has its own reference library. The Developer knows Cloudflare's API. The Klaviyo Expert knows flow architecture. The Designer knows Instagram's content-safe zones. They're not generalists guessing. They're specialists with documentation.

Tool access. Through MCP servers, each agent can interact with real systems. The Developer doesn't just suggest DNS records — it creates them. The Klaviyo Expert doesn't just describe a template — it builds one in the account. This is the difference between advice and execution.

Shared context. Every agent reads from and writes to the same client directory. There's no information loss between handoffs. The Developer sees exactly what the Designer specced. The Copywriter knows the brand voice the Designer established. Context flows through the system like data through a pipeline.

The Plugin Architecture

Under the hood, each agent is a Claude Code plugin. The structure is straightforward:

Every plugin has a SKILL.md file that defines who the agent is, what it does, what tools it can access, and what workflows it follows. Think of it as the agent's operating manual. It's the contract between me and the machine: "Here's your job. Here are your tools. Here's how you do the work."

Alongside that, there are reference directories full of domain knowledge. The Developer has deployment checklists and DNS guides. The Designer has platform specs and design principles. The Copywriter has SEO references and brand voice frameworks. This is the institutional knowledge that makes each agent useful.

The plugins live in a local marketplace — a directory of symlinks that point to the actual project code. Changes I make to any plugin take effect immediately. No reinstall, no rebuild, no deploy step. I edit the skill definition, and the next conversation uses it.

What's Next

I'm building this in public because I think the pattern matters more than the implementation. The specific tools will change. Claude will get better. New MCP servers will emerge. But the architecture — specialized agents with shared context and real tool access, coordinated by an orchestrator — that's the shape of things to come.

Next on the roadmap: tool leasing (giving clients temporary access to my MCP servers), an agent marketplace (letting other solo operators use the plugins I've built), and deeper automation in the handoff layer between agents.

The agency of the future isn't a bigger team. It's a better architecture.

I'm still the only human in the room. But the room is getting more capable every week.