5 Claude Code Subagents That Replace a 5-Person Team

By Lazar Milicevic · Published June 13, 2026 · 9 min read

Every discovery call this month sounded the same. Solopreneur drowning in email, leads going cold by day three, invoicing pushed to Sunday night, deliverables half-finished, and a four-hour YouTube course bookmarked but never opened. The founder doesn't need another SaaS subscription. They need five specialized agents wired into one terminal, sharing context, running on a schedule.

Here's the exact stack I deploy for clients — agent files, MCP configs, and the one slash command that runs my whole morning.

Why most "AI assistant" setups fail

Most tools fall into one of two traps. They're single-purpose SaaS that don't talk to your other tools — you end up with five subscriptions doing twenty percent of the work each. Or they're generic chat assistants with no hands. They suggest a reply but can't actually read your inbox, decide what's urgent, ping Telegram, draft the invoice in your accounting system, and log it to Postgres.

What moves the needle is specialization plus shared context. Each agent does one thing well. They all read the same CLAUDE.md, hit the same MCP servers, write to the same database. One terminal, one config, no vendor lock-in.

The structure on disk:

project-root/
├── CLAUDE.md                    # conventions, schema, agent roster
└── .claude/
    └── agents/
        ├── inbox-triage.md
        ├── lead-followup.md
        ├── invoicing.md
        ├── code-reviewer.md
        └── content-drafter.md
~/.config/claude/
└── mcp.json                     # Gmail, Telegram, Postgres, invoicing API

Each subagent is a single markdown file: name, description, allowed tools, system prompt. That's it. No framework, no orchestration platform.

What MCP actually gives you

• Gmail MCP — read threads, apply labels, mark read, send drafts
• Telegram MCP — send messages with inline approve/edit/skip buttons
• Postgres MCP — query the CRM, write logs, read project state
• Invoicing MCP — generate line items, push to e-invoicing endpoint, store PDF

MCP is the protocol that gives Claude hands. Without it, you have a clever chatbot. With it, you have an agent.

Subagent 1: Inbox triage (90 min → under 10)

The inbox agent reads new Gmail threads, classifies into four buckets — client, lead, vendor, noise — summarizes anything important in two lines, and pushes urgent items to Telegram with a reply button.

For a client running ~200 threads a day, morning inbox routine drops from roughly 90 minutes to under 10. The agent file is about 40 lines.

---
name: inbox-triage
description: Triage Gmail, classify, surface urgent threads to Telegram.
tools:
  - mcp__gmail__list_threads
  - mcp__gmail__get_thread
  - mcp__gmail__apply_label
  - mcp__telegram__send_message
---

You are the inbox triage agent for {{founder_name}}.

VIPs: {{vip_list}}
Tone: direct, lowercase, no filler.

For each unread thread since last run:
1. Classify into: client | lead | vendor | noise
2. Apply the matching Gmail label
3. If client OR lead AND (deadline mentioned OR VIP sender OR
   payment/contract keyword): push to Telegram with 2-line summary
   and "Reply" / "Snooze 4h" / "Archive" buttons
4. Skip noise silently. Never auto-reply.

The intelligence is in the system prompt — who the VIPs are, what "urgent" means for this founder, what tone to use in summaries. Forty lines, deployable in an afternoon.

Subagent 2: Lead follow-up (20–40 leads, zero forgotten)

This agent watches the leads Gmail label, checks days since last contact via the Postgres CRM, and drafts a follow-up that sounds like the founder — not like a Mailchimp template.

It does not send automatically. It posts the draft to Telegram with approve / edit / skip. One tap and it ships.

---
name: lead-followup
description: Draft daily follow-ups for cold leads, post to Telegram for approval.
tools:
  - mcp__postgres__query
  - mcp__gmail__create_draft
  - mcp__telegram__send_message
---

Every morning at 08:30:

SELECT lead_id, name, last_contact, last_message, stage
FROM leads
WHERE status = 'active'
  AND last_contact < NOW() - INTERVAL '3 days'
ORDER BY priority DESC LIMIT 10;

For each row:
- Pull the last 3 messages from thread history
- Draft a 4-6 sentence follow-up. Reference something specific
  from the last conversation. No "just checking in".
- Post to Telegram: [Approve & Send] [Edit] [Skip]
- Log the decision back to Postgres on callback

For an agency with 20–40 active leads, this is the difference between closing deals and watching them rot. The agent doesn't need to be clever. It needs to be on time, every day, without the founder remembering.

Subagent 3: Invoicing (8 min/invoice → under 1)

This is the agent that pays for the whole stack in the first month.

Trigger sources: a Telegram message ("invoice ClientX for sprint 3"), a calendar event marked "delivery", or a Stripe webhook. The agent pulls the client record, generates line items from the time log or project scope, applies the right tax rules, and either pushes to the e-invoicing system or drops a PDF for review.

For one client hand-typing 200 invoices a week, that's roughly 20 hours back, cleaner audit trail, and faster cash flow because invoices go out the day delivery happens.

---
name: invoicing
description: Generate and dispatch invoices from delivery signals.
tools:
  - mcp__postgres__query
  - mcp__invoicing__create_invoice
  - mcp__invoicing__send
  - mcp__telegram__send_message
---

Trigger: Telegram message matching /^invoice (\w+)/ OR webhook to /deliver

Steps:
1. Resolve client_id from name or webhook payload
2. Pull billable items: SELECT * FROM time_log
   WHERE client_id=$1 AND invoiced=false
3. Apply tax rules from clients.tax_profile (RS PDV / EU reverse charge / etc)
4. Build invoice payload, validate totals
5. If amount > 5000 EUR: post preview to Telegram, wait for approve
6. Else: send directly, store PDF, mark items invoiced=true
7. Log to invoices table with timestamp and source

The validation step matters. Threshold-based approval — small invoices auto-send, large ones get a human eyeball.

Subagent 4: Code reviewer (or deliverable reviewer)

If you ship any software, even a small internal tool, this one is non-negotiable. It runs on every commit, checks the patterns your CLAUDE.md flags as risky (raw SQL string concatenation, missing error handling, hardcoded secrets, no tests on new files), and posts a short review to Telegram.

It's not replacing a senior engineer. It's catching the obvious stuff so the founder doesn't ship broken code at midnight.

# .git/hooks/post-commit
#!/bin/bash
claude --agent code-reviewer \
  --input "$(git show --stat HEAD)" \
  --context "$(git diff HEAD~1 HEAD)" \
  > /tmp/review.md

For non-developer founders, swap this for a deliverable reviewer — same shape, different prompt. It checks proposals, contracts, or client reports against a quality checklist before they go out. Catches missing pricing tables, broken merge tags, wrong client name in section three. Cheap insurance.

What the reviewer actually checks

• Missing tests on files changed in this commit
• Patterns flagged in CLAUDE.md (auth bypasses, raw queries, console.log left in)
• Functions over 80 lines with no docstring
• Hardcoded values that look like secrets or env vars
• Breaking changes to public function signatures

Subagent 5: Content drafter (2 hours → 15 minutes)

Pulls the week's wins from the project log — shipped features, closed deals, problems solved — drafts three LinkedIn posts and one short email, drops them in a review folder. The founder spends 15 minutes editing instead of two hours staring at a blank page.

---
name: content-drafter
description: Weekly content from project wins. Friday 16:00.
tools:
  - mcp__postgres__query
  - Write
---

Every Friday at 16:00:

SELECT title, outcome, metric, client_anon
FROM project_log
WHERE completed_at > NOW() - INTERVAL '7 days'
  AND publishable = true;

Generate:
- 3 LinkedIn posts (one technical breakdown, one lesson, one
  before/after with numbers). Lazar's voice: direct, builder
  mindset, no hype phrases. Max 1 emoji.
- 1 short email (200 words) for the newsletter

Write to: ~/content/drafts/{YYYY-MM-DD}/

Marketing finally happens consistently. That's usually the difference between a stuck solopreneur and one that grows.

The wiring: one slash command runs the morning

The top-level CLAUDE.md names every subagent and when to invoke. The MCP config in ~/.config/claude/mcp.json connects Gmail, Telegram, Postgres, and the invoicing API once — every project inherits it.

Then there's one slash command. Call it /morning:

# .claude/commands/morning.md

Run this sequence and post a single daily briefing to Telegram:

1. Invoke @inbox-triage on threads since 18:00 yesterday
2. Invoke @lead-followup for any lead >3 days cold
3. Query: SELECT COUNT(*), SUM(amount) FROM invoices
   WHERE created_at::date = CURRENT_DATE - 1
4. Post briefing:
   - Inbox: X urgent, Y to review, Z archived
   - Leads: N drafts awaiting approval
   - Invoices yesterday: $amount across $count clients
   - Top 3 actions for today

Schedule it via cron at 07:30. By the time the founder opens Telegram with coffee, the day is triaged, leads are queued for one-tap approval, and the briefing is sitting there. Total run time on my PC-PC home server: about 90 seconds.

What this stack actually costs

• Claude API: ~$40–80/month for a single founder, ~$150/month for a small agency
• Home server / VPS: $0 if you already have one, $10–20/month otherwise
• MCP servers: open source, free
• Total: under $200/month to replace what would cost $15k+/month in hires

Why bizflowai.io helps with this

This is exactly the stack I deploy for clients at bizflowai.io — the inbox/lead/invoice trio is the core of what bizflowai.io-Catalyst runs in production, and the invoicing piece is Fakturko adapted to each client's tax rules. Most engagements take two to three weeks: discovery, MCP wiring, agent tuning to the founder's voice and VIP list, then a week of supervised runs before it goes autonomous on the morning briefing. If you want to copy the structure and self-host, the agent files above are enough to get started.

Frequently asked questions

What are Claude Code subagents?

Claude Code subagents are specialized AI agents defined as single markdown files inside a project's .claude/agents folder. Each file contains a name, description, allowed tools, and a system prompt. They share project context through a top-level CLAUDE.md file and use MCP (Model Context Protocol) connections to tools like Gmail, Telegram, Postgres, and invoicing APIs to actually perform tasks rather than just suggest actions.

Why do most AI tools fail solopreneurs and small agencies?

Most AI tools fail small operators because they're either single-purpose SaaS that don't integrate with other tools, or generic chat assistants with no ability to act. They can suggest a reply but can't read your inbox, classify urgency, ping Telegram, draft invoices in your accounting system, or log records to a database. Founders end up paying for multiple subscriptions while still doing the work manually.

How do I set up a Claude Code subagent?

Create a folder called .claude in your project, then an agents folder inside it. Add a markdown file containing the agent's name, description, allowed tools, and system prompt. Configure a top-level CLAUDE.md with project conventions and connected MCP servers. No orchestration framework or platform is required. A working agent file can be as short as forty lines.

What does an inbox triage subagent do?

An inbox triage subagent reads new Gmail threads, classifies them into buckets like client, lead, vendor, and noise, summarizes important messages in two lines, and pushes urgent items to Telegram with a reply button. For a client handling around 200 threads per day, this can reduce morning inbox time from roughly 90 minutes to under 10 minutes.

How much time can an invoicing subagent save?

An invoicing subagent reads project completion signals, pulls client records, generates line items from time logs or project scope, applies local tax rules, and sends the invoice or drops a PDF for review. For businesses hand-typing about 200 invoices per week, per-invoice time can drop from around eight minutes to under one minute, saving roughly twenty hours weekly with fewer typos.

Want more like this?

I publish practical AI automation, GenAI engineering, and faceless content workflows on YouTube every week.

Subscribe to bizflowai.io on YouTube — never miss a new tutorial.

Planning an AI automation project or need a second opinion on your architecture?

Connect with me on LinkedIn — Lazar Milicevic, GenAI Engineer & bizflowai.io Founder.

Visit bizflowai.io for our services, case studies, and AI consulting.