# How to build an ai-powered agency from $0 to $50k MRR:
**作者**: Machina
**日期**: 2026-05-05T13:59:54.000Z
**来源**: [https://x.com/EXM7777/status/2051663177746878760](https://x.com/EXM7777/status/2051663177746878760)
---
For the first time in the history of the agency model, the bottleneck between you and $50K a month is no longer a person you have to find, hire, train, manage, and probably eventually fire
it is a stack of tools that runs for around $200 a month if you sit down a minute and wire them up correctly
what you are about to read is the entire shape of that wiring, end to end, the way it runs inside the slack workspaces that are quietly clearing $20K, $40K, $50K MRR right now without any of the things you used to need
specifically you are going to walk away with all of this:
- the 6 phases of building from $0 to $50K a month, solo, end to end
- the canonical agent stack, claude code, codex, a memory layer (hermes or openclaw, pick one), Roman agent, and which agent does which job
- the slack workspace architecture, the actual channel topology that runs the whole thing, drop-in for monday morning
- the cold outreach pattern, both playbooks, with the Roman agent workflows that run 20 to 40 hyper-targeted prospects per week without you opening apollo or instantly
- the 3-gate scaling ladder, $5K, $20K, $50K, and exactly what breaks first at each gate so you do not break with it
- the 80/20 split, what the agent owns, what stays human, and the line between them that decides whether you compound or commodity
let’s get into it
## the bottleneck has changed shape, and almost nobody has metabolized it yet
in 2024 the math went like this... you wanted to build an agency, you needed a sales manager, a head of ops, a junior designer, a project manager, a copywriter, and probably a virtual assistant somewhere in the philippines just to keep the calendar honest
you needed all of them before you cleared $20K a month, which is why so many people who tried this and gave up
the math now goes like this... 10 clients at $5K a month is $50K a month
the gross margin on that math is insane because of the actual delivery work is now handled by agents that cost roughly $50-60 a month each, and the headcount required to run the operation is 1, which is you
this is not a forecast, it is the shape of the businesses already doing it
the only thing that changed between 2024 and now is the substrate the agents (and their capabilities) live on, which is slack, and the fact that as of february 2026 every meaningful ai agent on earth can read and write into slack the same way a human teammate would
so the bottleneck stopped being labor and became wiring
slack is the operating system the wiring runs on, the agents are contractors that live in channels, you are the only human in the room and that is the entire point
in 2024 this would have been a hiring problem, in 2026 it is a systems problem, and anyone with a laptop can solve a systems problem... that is also why almost nobody will
## phase 1, the niche is mechanical, not creative
every newcomer to this model picks "ai consulting" or "ai automation" as their service category and dies in the first 90 days, because horizontal ai services are the most commoditized category in the entire market right now, and you are competing against an infinite supply of n8n youtubers selling the same template to the same buyers in the same week
the trap is the word ai in the offer, which signals to the buyer that you are selling a tool, not an outcome, and tools are evaluated on price while outcomes are evaluated on value
fix this in the first sentence of your pitch, by removing the word ai and replacing it with the specific recurring expensive workflow the buyer already pays someone to do badly
the pattern that holds at $50K MRR is recurring + high-intent + narrow ICP, with the emphasis on the third one... narrow is the entire game
3 service shapes are clearing this number in 2026:
- productized service. flat monthly retainer, fixed scope, public pricing on the site, the buyer chooses themselves
- ai-augmented retainer. custom scope per client, agents do the throughput, you own the strategy and the relationship
- async deliverable. outcome-based, the deliverable is the entire product, no meetings, no calls, just the finished thing dropped into the buyer's slack channel on a recurring schedule
the validation rule is unambiguous and you do not break it... the niche is real when 3 prospects pay a deposit, not when 30 say "interesting" on a survey, and not when 50 people like your post about the idea on X
cash on the table or the niche does not exist
the validation work itself is a getroman.ai workflow you queue once and let run overnight
you tell roman the niche in your slack ops channel, roman pulls TAM estimates, scrapes the last 30 days of job postings for the pain you solve, surfaces the trigger events that put the icp into market right now, builds a 100-account list with named contacts and budget signals, ranks the top 3 pains by ai-leverage, and posts the verdict back into the channel as a one-page memo before you wake up
no perplexity tab... no manual prospect spreadsheet, just a slack message
run this against the 3 niches you are torn between, and the verdict almost always picks itself by the time you read the second one
the median time to $10K MRR for an operator running this pattern is 6 months i’d say... which means if you pick the niche today and you have not signed a deposit by month 4, the niche is wrong and you start again, you do not push harder on a wrong niche for 9 more months hoping it cracks open
once the niche is real, the next decision is not what to sell, it is what to build the agents to do, and that decision has a single number attached to it that almost nobody gets right on the first try
## phase 2, 60% moves to the agents, 40% stays human, and the split decides everything
i like the term “ai-powered”, but many people get it wrong
every newcomer assumes it means "ai does everything," and the first time the agent ships something off-spec to a client, the client fires them, and they spend the next month telling everyone on X that ai is overrated… when what was overrated was their understanding of what ai does
the split is structural and it is not negotiable... 80% of the throughput moves to the agents, 20% stays with you, and the line between them is where you live or die
the agents own all of this:
- research and synthesis
- first drafts of every deliverable
- data extraction, formatting, repetitive QA
- scheduling, follow-ups, status updates
- long-running background tasks while you are at the gym
you own all of this:
- the spec
- the taste decisions
- the judgment calls on edge cases
- the client-facing strategic conversation
- the final ship-or-not approval
the failure mode is not "ai does the work, human reviews," because that frames the human as a rubber stamp and the agent as the protagonist, which is backwards
the correct frame is "human owns the spec and the taste, agent owns the throughput," and the human shows up at the moments where taste and judgment are the product
the canonical stack, which you pick once and stop adding to:
claude code, codex, openclaw or hermes: the engineer in the terminal, $200/month, it is the build environment most agencies switched to in 2026
Roman agent, the contractor that lives in your slack channel, the only agent in this stack where slack is not an integration, slack is the entire surface
you wire them all into the right slot, and the slot is decided by where the work happens
## phase 3, the cold-email arms race is over for solo operators, the deliverable is the message
the move is not to send more, the move is to send smarter, and there are 2 ways smart looks in 2026
playbook A, the slack-orchestrated classic. apollo for sourcing, clay for waterfall enrichment, which drops bounce from 2.5-4% down to under 1.5%, instantly or smartlead for sending with 6-8 weeks of warmup, and replies route into a slack channel where Roman agent handles triage and the human approves the next move
playbook B, the deliverable-as-outreach pattern. you build the finished asset for the prospect first, a 30-second ad cut, an audit, a rewritten landing page, a sample list, whatever the actual outcome looks like for that prospect specifically, and you send it cold with no pitch
the asset is the message, the follow-up is one word, no calendar link, no friction, the prospect either replies "more" or they do not
this works in 2026 because volume is intrinsically low, you cannot fake a finished thing, the prospect cannot accuse you of being a template, and it filters perfectly for people who have the problem you solve, because the people who do not have the problem do not engage with the asset at all
for playbook B, getroman runs the asset build itself overnight
you queue the prospect list in your slack outreach channel
Roman scrapes each prospect's site, their last 30 days of public posts, their PH launch comments, their open job listings, their stripe page if it is public, and produces a personalised audit, sample list, or rewritten asset for each one
it drops the finished things into the channel as 1 thread per prospect, and you spend 20 minutes on the next day reviewing and hitting send
the prospect receives a finished thing they did not pay for, the follow-up is one word, the asset is the entire message, and your time on the loop is the 20 minutes of human review at the end
for playbook A, agents handle the back half of the loop
Apollo, clay and instantly source and send, replies route into the slack outreach channel, another agent classifies each reply by intent (interested, objection, not now, wrong-person), drafts your half of the response in your voice using the memory layer's context on past conversations, posts the draft in-thread, you ship with a slack reaction or rewrite in 3 lines
30 replies a week takes 30 minutes of your time end to end, instead of the 4 hours of inbox triage it would have cost a year ago
the elite operators are not running both playbooks against the same list, they are picking 1, running it for 90 days, killing it if reply rates do not crack 3% on playbook a or 20% on playbook B, and starting the next list the next monday
the cold email arms race is not a volume game anymore, it is a precision game, and precision is what the agents are for
the harder question is what you put in the asset itself, because the whole pattern collapses if the deliverable you are sending cold could have been written about any company in the prospect's category by any author on their stack, which is the same wall the content engine hits in the next phase
## phase 4, ai is for amplification, never generation, and that is the line that decides whether you compound or commodity
ai shows up at research synthesis, at repurposing, at distribution, at triage, at analytics
ai does not show up at the layer where you decide what you think about something, and that single line decides whether you compound or commodity
the operators who collapse the generation layer into ai lose differentiation in a single quarter, because every ai output trained on the public internet sounds like every other ai output trained on the public internet
the moment your post could have been written about any company in your category by any author on your stack, you are not writing anymore, you are generating, and generating loses to writing every single time the two are placed next to each other
the test is one sentence... would a competitor's ai produce this exact post if you fed it the same brief?
if the honest answer is yes, you do not ship it, you sit back down and write it yourself, badly at first, and let the badness teach you what you believe about the thing
the cadence that works for solo operators in 2026, drop-in:
the inbound dm reply rate from a founder with 10K engaged followers and a clear offer is 8-15%, the reply rate from a cold dm is 0.5-2%
30 minutes a day spent replying to inbound is doing roughly 15x the work of an hour spent sending cold dms, and that is before you account for the fact that the inbound conversations close at 3-5x the rate of cold ones
what ai is for, here, is the amplification of what you have already said, never the generation of what you would have said
you record a 10-minute voice memo on monday morning, the memo contains 1-3 actual insights buried in digressions, and your agent handles the entire amplification layer from there
it pulls the transcript, extracts the 1-3 insights you actually said, restructures each one into a long-form x post, a linkedin post sized for that platform's reading pattern, 3 short-form variants from different angles, and a newsletter section that uses the insight as the spine
Roman posts the full set into your slack content channel as a thread, and flags every place it wanted to extrapolate beyond what you said as a what i refused to write note at the bottom of the thread
10 minutes of voice memo on monday morning becomes the entire week of distribution
the discipline that makes this not slop is the refusal note at the bottom of the thread, which forces the agent to surface every place it wanted to invent rather than restructure, and that note is the line between amplification and generation, and you do not cross it
Roman runs the analytics half of the loop too
it pulls last week's post performance from x and linkedin, identifies which insights got engagement and which died on arrival, scores reply patterns by audience segment, and posts a one-page distribution memo into the content channel every saturday morning before the newsletter goes out
you know which line to lead the next week with before you sit down to record the next voice memo
amplification only matters if the throughput on the other side of it is real, which means the part of the operation almost everyone underbuilds is the part you are about to walk into, the delivery layer
## phase 5, the channel is the org chart, the agent is the contractor, the audit log is the lock-in
clients in 2026 already assume ai is somewhere in the loop, and the operators losing to ai-skeptical buyers are losing because they tried to hide it, not because they used it
the data has flipped completely... operators putting [AI-drafted, human-approved] tags on their deliverables are getting higher renewal rates than operators trying to pass everything off as fully hand-typed, because the tag becomes a trust signal instead of a confession
so the architecture of how you deliver work has to be transparent on purpose, and the way you make it transparent is the channel topology, which is the entire point of using slack as the operating system in the first place
here is what the workspace looks like, drop-in, fork it into your own:
my-agency-workspace/
├── # WAR ROOM
│ ├── #standup ← daily morning brief from agents
│ ├── #wins ← revenue + delivery wins
│ └── #fires ← anything urgent, human-only
├── # OPERATIONS
│ ├── #ops ← getroman delivers finished work here
│ ├── #revenue ← stripe webhooks, MRR pings, churn alerts
│ ├── #outreach ← apollo/clay/instantly, reply triage
│ ├── #scheduling ← cal.com bookings + calendar conflicts
│ └── #ai-bots ← bot-to-bot scratchpad, debug, logs
├── # CLIENTS (one channel per active retainer)
│ ├── #client-acme ← shared with client + their team
│ ├── #client-beta ← slack connect channel
│ └── #client-gamma
└── # CONTRACTORS
├── #editor-jenna ← human VA / editor
└── #dev-priya ← part-time engineer
this is roughly 12 channels and it is the entire org chart of a solo agency clearing 5-figure-a-month MRR
the only thing that makes it not collapse into chaos is one rule, taken directly from the operators who run the multi-bot pattern in production, and you do not break it... every bot response goes in the thread of the initial message, no exceptions
without the threading rule, the multi-bot pattern turns the channels into a wall of agent chatter and the human router problem comes back, and you are right back to copy-pasting context between tools instead of letting the channels carry it
the canonical delivery loop, the 8-step path from a client message to a shipped deliverable, runs like this:
1. intake. client posts a request in #client-acme, or a scheduled cron triggers it ("every monday 9am, run last week's content audit")
2. classify. @delivery-bot reads the message, checks against the pinned service spec doc, and posts a clarifying question if the request is out of scope
3. execute. the bot pulls the memory layer for client context, runs the delivery template, drafts the output
4. QA gate. the bot runs the internal QA checklist against the draft, posts the draft and the checklist results to #client-acme-internal with an :eyes: reaction
5. human ship gate. you review, you ship with :rocket:, or you request a revision in the thread
6. deliver. the bot posts the final artifact to #client-acme with a thread link to the audit log entry
7. log. the run is appended to the client's audit dataset with timestamp, input, model and tools used, output, QA results, reviewer id
8. update memory. the memory layer ingests the run for next time, the agent gets slightly better at this specific client
the QA gate itself is an agent skill you wire once and forget
your agent checks every draft against the pinned service spec, matches voice against the memory layer's profile for that specific client, verifies citation density on every numeric claim, confirms format compliance against the client's canonical output template, runs the client glossary check against their preferred terminology, scrubs for agent self-references and other-client PII leaks, and confirms the audit log entry exists with all required fields populated
if any of those checks fail, your agent writes a one-line diagnosis, posts it into #client-X-internal with a :warning: reaction, and refuses to ship the deliverable into the client channel until the diagnosis is resolved
the human ship gate stays human, but the gate itself is held by roman
every frida, your agent drops weekly client reports into each client's shared slack channel, pulled from their hubspot, their stripe, their analytics, written, formatted, posted, every single friday, without you touching it
most teams running this pattern are up and running on it in under 5 minutes, which is roughly the same 5 minutes the simplest claude code setup takes to wire
agents that live in channels, work that is delivered in channels, no context lost in translation
the lock-in is the channel itself
once a client has 6 months of context, audit logs, and agent memory inside their shared channel with you, switching costs are no longer your contract, they are the 18 months of agent-curated context that walks out the door if they leave
the renewal conversation at month 12 is not a conversation about price, it is a conversation about what they would lose, and they almost never leave, which is exactly the moment most operators discover that retention bought them runway and then broke their delivery model under load
## phase 6, 3 gates, 3 different things break, you only get to the next gate by knowing which
the operators who try to jump from $5K to $50K in one move tend to break around $12K to $15K a month, because they did not build the audit log and the retention motion at gate 1, and now their book is leaking faster than they can fill it, and they spend the next 6 months climbing back to $20K with damaged trust on half their accounts
the 3 gates, in order, with what breaks first at each:
gate 1, $5K MRR, "make it stand up." what breaks first is your own delivery time, because every new client adds proportional hours and you are doing 60-hour weeks and the math does not work
the fix is not a hire, it is 2 or 3 agent workflows for the highest-frequency tasks, claude code drafting, the memory layer maintaining client context, Roman in the background for unattended runs, and a $4K to $5K a month productized floor with public pricing on the site so the buyer chooses themselves
you do not hire a contractor at $5K MRR, you hire agents
gate 2, $20K MRR, "buy back your time." what breaks first is you, because the bottleneck at $20K a month is rarely throughput, it is executive function
you are the QA gate, the salesperson, the ops manager, the renewal owner, the sleep is gone, the churn risk is climbing
the contrarian fix is to hire a project manager contractor before you hire a delivery contractor, 10-15 hours a week, $30-$50/hour for a senior US-based PM, $15-$25 offshore, and you give them the calendar, the comms, the QA-against-the-checklist, and 3 or 4 more agent workflows to handle outreach reply triage, memory-driven context loading, and slack MCP renewal alerts
the first contractor is for you, not for the work, and the moment your scheduling and your client comms stop routing through your brain, your delivery throughput rises automatically
gate 3, $50K MRR, "productize the operator." what breaks first is the fact that you cannot be the central node anymore, because every decision still routes through you and the system cannot scale past your calendar
the fix is to move the top 1 to 3 accounts onto hybrid base plus outcome pricing, 40-60% base, the rest earned through measurable result, raise the productized floor for new accounts to $8K a month, take the contractor to 20-25 hours a week or convert to full-time, and run 8-12 agent workflows unattended
at this gate, less than 15% of top-performing agencies are still billing hourly, the entire industry has moved to value-based pricing, and you move with it or you lose the next renewal cycle
3 numbers worth absorbing as anchors:
- bring on the first contractor at $3K to $5K MRR if and only if the highest-frequency task is something an agent cannot reliably do yet, otherwise wait
- the solo agency conversion threshold is $15K to $20K MRR sustained for 3 months before hiring a full-time team member, anything earlier and you have not learned the workflow well enough to hand it off
- productized service minimum viable price is $4K to $5K a month for one operator's P&L to clear, and any account below that floor at gate 1 is the first one you nudge to the new floor at gate 2
the renewal motion is built at gate 1 or it is never built
you cannot bolt on retention at $20K MRR, you have to design for it from the first deliverable, which is why every client gets the audit log, the weekly cadence, the quarterly business review, the per-client custom annual planning session, from the moment they sign
the operators who treat retention as a phase 6 problem are the ones who break at $12K and the ones who treat it as a phase 1 design constraint are the ones who clear $50K with a 6-week waitlist
what no operator running this pattern can ignore at $50K MRR is that the entire stack only holds because of one substrate underneath all of it, and the substrate has only been load-bearing in the way it now is for the last 90 days
## the operating system, and the part where the metaphor breaks
every "ai agency" stack falls apart for the same reason... the agents live in one tool, the humans live in another, the work product lives in a third, and the operator becomes a human router copy-pasting context between claude, linear, notion, gmail, and the client
that does not scale to 5 retainers, much less 10, and the entire reason solo agencies historically capped at $20K MRR was the bandwidth ceiling of one human acting as the message bus for an entire org chart
3 things converged in late 2025 and early 2026 that made slack categorically different from any prior chat tool, not as a degree, as a kind:
- late 2025. anthropic ships interactive apps inside claude.ai, and slack is one of the 9 launch integrations alongside notion, figma, canva, box, clay, asana, amplitude, hex, monday... you can draft, preview, and post a slack message without leaving claude
- early 2026. slack ships its mcp server, mcp being model context protocol, the open standard anthropic introduced that lets any ai client read and write external tools the same way a human teammate would. external clients, claude desktop, claude code, perplexity, cursor, can now talk to slack natively under that protocol. slack reports a 25x increase in mcp tool calls inside slack since the october 2025 limited release, and over 50 context-aware agents have already shipped against the new surface
- march 2026. salesforce ships 30 new ai features in slack and turns slackbot itself into a full mcp client, which means slackbot stops being a conversational sidekick and starts coordinating work across the entire connected stack via natural language, and slack stops being a chat app and becomes the agent execution layer
the combined effect is that slack is now the only place on earth where the operator, the autonomous coworker, the channel-bound bots, the deal data from apollo and clay and stripe, the project state from linear and notion, and the meeting transcripts all sit in the same searchable, permissioned, agent-readable index
that is the operating system argument, and everything else is feature comparison
so it is fair to say slack is your co-founder, and it is honest to say that is true except for the parts where it isn't
a co-founder, in the practical sense, has a specific set of properties... always on, knows your context, acts on your behalf, has its own opinions, owns a function, coordinates with the rest of the team
slack-with-agents-installed delivers all 6 of those properties... the channel is the function, the bot is the coordinator, the memory layer is the persistent context that knows your client, and roman is the contractor that acts on your behalf at 3 in the morning while you are asleep
what the metaphor does not deliver is also worth saying out loud
no equity, no skin in the game, no aligned incentive over years, the agents are rented compute and if anthropic raises prices 3x tomorrow the "co-founder" gets fired which a real co-founder does not
no taste under uncertainty, the agents are excellent at execution and weak at "should we even be doing this," and the operator still owns positioning, pricing, who to fire as a client, when to pivot
no interpersonal layer, the agent does not know that a client got drunk at the offsite or that a contractor is going through a divorce, and the human relationship that matters most in service businesses is not modeled
so the honest landing is prosthetic co-founder
closer to a co-founder than anything you have ever sat next to in a working environment, and far enough away that you should not get cocky about it
the discipline that follows from that is to architect your workspace so the channel structure is portable, because if slack reprices the bot economics tomorrow you do not lose the company, you lose the URL, and the channel structure ports to mattermost in an afternoon
the agents own throughput, the human owns taste, that is the only line that matters and the only line that compounds
the door is open, the room is furnished, the agents are waiting in the channels for you to write the first message
the wiring is above, the tools are in the channels, the only move left is the first one, and the first one is always smaller than the article made it look
thank you getroman.ai for sponsoring this article
## 相关链接
- [Machina](https://x.com/EXM7777)
- [@EXM7777](https://x.com/EXM7777)
- [68K](https://x.com/EXM7777/status/2051663177746878760/analytics)
- [$50K](https://x.com/search?q=%2450K&src=cashtag_click)
- [$20K](https://x.com/search?q=%2420K&src=cashtag_click)
- [$40K](https://x.com/search?q=%2440K&src=cashtag_click)
- [$50K](https://x.com/search?q=%2450K&src=cashtag_click)
- [$50K](https://x.com/search?q=%2450K&src=cashtag_click)
- [$5K](https://x.com/search?q=%245K&src=cashtag_click)
- [$20K](https://x.com/search?q=%2420K&src=cashtag_click)
- [$50K](https://x.com/search?q=%2450K&src=cashtag_click)
- [$20K](https://x.com/search?q=%2420K&src=cashtag_click)
- [$5K](https://x.com/search?q=%245K&src=cashtag_click)
- [$50K](https://x.com/search?q=%2450K&src=cashtag_click)
- [$50K](https://x.com/search?q=%2450K&src=cashtag_click)
- [getroman.ai](https://getroman.ai/)
- [$10K](https://x.com/search?q=%2410K&src=cashtag_click)
- [#standup](https://x.com/search?q=%23standup&src=hashtag_click)
- [#wins](https://x.com/search?q=%23wins&src=hashtag_click)
- [#fires](https://x.com/search?q=%23fires&src=hashtag_click)
- [#ops](https://x.com/search?q=%23ops&src=hashtag_click)
- [#revenue](https://x.com/search?q=%23revenue&src=hashtag_click)
- [#outreach](https://x.com/search?q=%23outreach&src=hashtag_click)
- [#scheduling](https://x.com/search?q=%23scheduling&src=hashtag_click)
- [cal.com](https://cal.com/)
- [#ai](https://x.com/search?q=%23ai&src=hashtag_click)
- [#client](https://x.com/search?q=%23client&src=hashtag_click)
- [#client](https://x.com/search?q=%23client&src=hashtag_click)
- [#client](https://x.com/search?q=%23client&src=hashtag_click)
- [#editor](https://x.com/search?q=%23editor&src=hashtag_click)
- [#dev](https://x.com/search?q=%23dev&src=hashtag_click)
- [#client](https://x.com/search?q=%23client&src=hashtag_click)
- [@delivery](https://x.com/@delivery)
- [#client](https://x.com/search?q=%23client&src=hashtag_click)
- [#client](https://x.com/search?q=%23client&src=hashtag_click)
- [#client](https://x.com/search?q=%23client&src=hashtag_click)
- [$5K](https://x.com/search?q=%245K&src=cashtag_click)
- [$50K](https://x.com/search?q=%2450K&src=cashtag_click)
- [$12K](https://x.com/search?q=%2412K&src=cashtag_click)
- [$15K](https://x.com/search?q=%2415K&src=cashtag_click)
- [$20K](https://x.com/search?q=%2420K&src=cashtag_click)
- [$5K](https://x.com/search?q=%245K&src=cashtag_click)
- [$4K](https://x.com/search?q=%244K&src=cashtag_click)
- [$5K](https://x.com/search?q=%245K&src=cashtag_click)
- [$5K](https://x.com/search?q=%245K&src=cashtag_click)
- [$20K](https://x.com/search?q=%2420K&src=cashtag_click)
- [$20K](https://x.com/search?q=%2420K&src=cashtag_click)
- [$50K](https://x.com/search?q=%2450K&src=cashtag_click)
- [$8K](https://x.com/search?q=%248K&src=cashtag_click)
- [$3K](https://x.com/search?q=%243K&src=cashtag_click)
- [$5K](https://x.com/search?q=%245K&src=cashtag_click)
- [$15K](https://x.com/search?q=%2415K&src=cashtag_click)
- [$20K](https://x.com/search?q=%2420K&src=cashtag_click)
- [$4K](https://x.com/search?q=%244K&src=cashtag_click)
- [$5K](https://x.com/search?q=%245K&src=cashtag_click)
- [$20K](https://x.com/search?q=%2420K&src=cashtag_click)
- [$12K](https://x.com/search?q=%2412K&src=cashtag_click)
- [$50K](https://x.com/search?q=%2450K&src=cashtag_click)
- [$50K](https://x.com/search?q=%2450K&src=cashtag_click)
- [$20K](https://x.com/search?q=%2420K&src=cashtag_click)
- [claude.ai](https://claude.ai/)
- [getroman.ai](http://getroman.ai/)
- [Upgrade to Premium](https://x.com/i/premium_sign_up)
- [9:59 PM · May 5, 2026](https://x.com/EXM7777/status/2051663177746878760)
- [68.8K Views](https://x.com/EXM7777/status/2051663177746878760/analytics)
- [View quotes](https://x.com/EXM7777/status/2051663177746878760/quotes)
---
*导出时间: 2026/5/6 14:10:24*
---
## 中文翻译
# 如何将一家 AI 驱动的代理机构从 0 做到 5 万美元月经常性收入：
**作者**: Machina
**日期**: 2026-05-05T13:59:54.000Z
**来源**: [https://x.com/EXM7777/status/2051663177746878760](https://x.com/EXM7777/status/2051663177746878760)
---
在代理商模式的历史上，这是第一次，横在你与月入 5 万美元之间的瓶颈，不再是那个你必须去寻找、雇佣、培训、管理，并且最终可能还要解雇的人。
而是一套工具栈，如果你坐下来花点时间正确地连接它们，这套工具的运行成本大约只有每月 200 美元。
你即将读到的是这套连接方案的完整架构，端到端的全景。这正是那些 Slack 工作区在当下悄无声息地实现 2 万美元、4 万美元、5 万美元月经常性收入（MRR）的运作方式，而你不再需要以前那些必备的条件。
具体来说，读完本文你将获得所有这些：
- 从 0 到月入 5 万美元的 6 个阶段，单人独立完成的全流程
- 标准的智能体栈：Claude Code、Codex、记忆层、Roman 智能体，以及哪个智能体负责哪项工作
- Slack 工作区架构，实际运行整个系统的频道拓扑结构，周一上午即可直接投入使用
- 冷启动外展模式，包含两套操作手册，以及 Roman 智能体工作流：每周无需打开 Apollo 或 Instantly 即可自动触达 20 到 40 个高度精准的潜在客户
- 3 道门槛的扩展阶梯：5 千美元、2 万美元、5 万美元，以及每一道门槛最先会出问题的地方，确保你不会随之崩溃
- 80/20 分工法则，智能体负责什么，什么由人工保留，以及决定你是建立复利优势还是沦为大众商品的界线所在
让我们开始吧。
## 瓶颈的形态已经改变，几乎还没人意识到这一点
在 2024 年，数学逻辑是这样的……你想开一家代理商，你需要一名销售经理、一名运营主管、一名初级设计师、一名项目经理、一名文案，可能还需要一名在菲律宾的虚拟助手，仅仅是为了确保日程表不出错。
在月收入达到 2 万美元之前，你就需要雇齐所有这些人，这也是为什么那么多尝试过的人最终选择了放弃。
现在的数学逻辑是这样的……10 个每月支付 5 千美元的客户，就是 5 万美元的月收入。
这个公式的毛利率高得离谱，因为实际的交付工作现在由智能体处理，每个的成本大约在每月 50-60 美元，而运营这个业务所需的人员编制只有 1 人，也就是你。
这不是预测，这是已经在这么做的商业实体的现状。
2024 年至今唯一的变化在于智能体（及其能力）赖以生存的基底，即 Slack，以及一个事实：截至 2026 年 2 月，地球上每一个有意义的 AI 智能体都可以像人类队友一样读写 Slack。
所以瓶颈不再是劳动力，而是连接线路。
Slack 是运行这些线路的操作系统，智能体是住在频道里的承包商，你是房间里唯一的人类，而这就是全部的重点。
在 2024 年，这会是一个招聘问题；在 2026 年，这是一个系统问题，任何有一台笔记本电脑的人都能解决系统问题……这也是为什么几乎没人能解决的原因。
## 第一阶段，利基市场是机械选择，而非创意选择
每个刚进入这个模式的新人都会选择“AI 咨询”或“AI 自动化”作为他们的服务类别，然后在最初的 90 天内夭折。因为横向的 AI 服务是当前整个市场上最同质化的类别，你是在与无数个 n8n 的 YouTuber 竞争，他们在同一周内向同一批买家兜售着相同的模板。
陷阱在于报价中的“AI”一词，它向买家传递的信号是你在销售一种工具，而不是一个结果。工具是以价格来评估的，而结果是以价值来评估的。
在你的推销词的第一句话里修正这个问题，去掉“AI”这个词，替换为买家目前已经花钱让人在做的、具体的、重复发生的、昂贵的工作流程。
在 5 万美元 MRR 的水平上依然有效的模式是：重复性 + 高意向 + 窄众理想客户画像（ICP），重点在于第三点……窄众就是整个游戏的关键。
在 2026 年，有 3 种服务形态能够达到这个数字：
- 产品化服务。固定月费，固定范围，公开网站定价，买家自助选择。
- AI 增强型年费。针对每个客户定制范围，智能体负责吞吐量，你拥有策略和客户关系。
- 异步交付品。基于结果，交付物本身就是完整产品，无会议，无通话，只有完成的成品按预定时间表投放到买家的 Slack 频道中。
验证规则是明确的，不可打破……当 3 个潜在客户支付了定金时，利基市场才算成立；而不是在调查中有 30 个人说“有点意思”；也不是在 X 上有 50 个人喜欢你关于该想法的帖子。
桌子上有真金白银，否则利基市场就不存在。
验证工作本身就是一个 getroman.ai 的工作流，你排队设置一次，然后让它过夜运行。
你在 Slack 运营频道中告诉 Roman 你的利基市场，Roman 会拉取市场规模估算（TAM），抓取过去 30 天内针对你所解决问题的职位发布， surfacing 触发事件，找出当下将 ICP 推向市场的因素，建立一个包含 100 个账号的名单（含具体联系人及预算信号），按 AI 杠杆率对前 3 大痛点进行排序，并在你醒来之前将结论作为一份单页备忘录发布回频道。
没有 Perplexity 标签页……没有手动的潜在客户电子表格，只有一条 Slack 消息。
针对你犹豫不决的 3 个利基市场运行这个流程，当你读完第二份报告时，结论通常就显而易见了。
我认为，按照这种模式运营的从业者达到 1 万美元 MRR 的中位时间是 6 个月……这意味着如果你今天选定了利基市场，而在第 4 个月前还没签下定金，那么利基市场就选错了，你需要重新开始。不要在一个错误的利基市场上再死磕 9 个月，指望它能突然开窍。
一旦利基市场确认为真实存在，下一个决定不是卖什么，而是构建智能体去做什么，这个决定只取决于一个数字，几乎没人能在第一次尝试时就把这个数字弄对。
## 第二阶段，60% 移交给智能体，40% 留给人类，这个分工决定一切
我喜欢“AI 驱动”这个词，但很多人理解错了。
每个新手都以为这意味着“AI 做所有事”，而一旦智能体发给客户的东西不符合规格，客户就会解雇他们。接下来的一个月里，他们会逢人就在 X 上说 AI 被高估了……其实被高估的是他们对 AI 功能的理解。
这种分工是结构性的，没有商量的余地……80% 的吞吐量移交给智能体，20% 留给你，而两者之间的界线就是你生死攸关的地方。
智能体拥有所有这些职责：
- 研究与综合
- 所有交付物的初稿
- 数据提取、格式化、重复性 QA
- 日程安排、跟进、状态更新
- 你在健身房时进行的长时间后台任务
你拥有所有这些职责：
- 规格
- 审美决策
- 针对边缘情况的判断
- 面向客户的战略对话
- 最终的发货与否的批准权
失败的模式不是“AI 做工作，人类审核”，因为这种模式把人类变成了橡皮图章，把智能体变成了主角，这是本末倒置。
正确的框架是“人类拥有规格和审美，智能体拥有吞吐量”，人类出现在那些品味和判断本身就是产品的时刻。
标准栈，你选定一次后就不再添加：
Claude Code、Codex、OpenClaw 或 Hermes：终端里的工程师，每月 200 美元，这是 2026 年大多数代理商转而采用的构建环境。
Roman 智能体，住在你的 Slack 频道里的承包商，这是这个栈中唯一的 Slack 不是作为一个“集成”而存在的智能体，Slack 就是它的整个操作界面。
你要把它们全部连接到正确的位置，而这个位置取决于工作发生在哪里。
## 第三阶段，针对单人经营者的冷邮件军备竞赛已经结束，交付物就是信息
这一步的关键不是发得更多，而是发得更聪明，在 2026 年，“聪明”有两种样子。
操作手册 A，Slack 编排的经典模式。Apollo 用于寻找线索，Clay 用于瀑布式富化，这将退信率从 2.5-4% 瞬间降至 1.5% 以下，Instantly 或 Smartlead 用于发送（需 6-8 周预热），回复会被路由到一个 Slack 频道，在那里 Roman 智能体进行处理分诊，人类批准下一步行动。
操作手册 B，“交付物即外展”模式。你首先为潜在客户构建成品的资产，一段 30 秒的广告剪辑、一份审计报告、一个重写的落地页、一份示例列表，任何针对该特定客户实际结果的样貌，然后你进行冷启动发送，不带任何推销辞令。
资产就是信息，跟进只有一个词，没有日历链接，没有任何摩擦，潜在客户要么回复“更多”，要么就不回。
这在 2026 年之所以有效，是因为体量本质上很低，你无法伪造一个完成品，潜在客户无法指责你使用模板，并且它能完美筛选出那些拥有你解决的问题的人，因为没有这个问题的人根本不会与该资产互动。
对于操作手册 B，getroman 会连夜运行资产构建本身。
你在 Slack 外展频道中排队潜在客户名单。
Roman 抓取每个潜在客户的网站、过去 30 天的公开帖子、他们在 PH（Product Hunt）发布的评论、他们的招聘信息、以及他们的 Stripe 页面（如果是公开的），并为每个人生成个性化的审计报告、示例列表或重写的资产。
它会将完成品按每个潜在客户一个主题串的形式投放到频道中，第二天你花 20 分钟审核并点击发送。
潜在客户收到了一个他们未付费的完成品，跟进只用一个词，资产就是全部的信息，而你在整个循环中的时间就是最后那 20 分钟的人工审核。
对于操作手册 A，智能体处理循环的后半段。
Apollo、Clay 和 Instantly 负责寻找和发送，回复被路由到 Slack 外展频道，另一个智能体根据意图对每条回复进行分类（感兴趣、有异议、现在不需要、找错人了），利用记忆层关于过去对话的上下文，用你的语气起草你那一半的回复，将草稿发布在主题串中，你通过一个 Slack 表情回复或重写 3 行文字来发送。
每周 30 条回复从头到尾只需花费你 30 分钟，而不是一年前需要的 4 小时收件箱分诊时间。
精英运营者不会对同一个名单同时运行两套手册，他们选定 1 个，运行 90 天，如果操作手册 A 的回复率没破 3% 或操作手册 B 没破 20%，就弃用这套手册，并在下个周一开始下一个名单。
冷邮件军备竞赛不再是一个体量游戏，而是一个精准度游戏，而精准度正是智能体的用途所在。
更难的问题是你在这个资产里放什么，因为如果你冷启动发送的交付物本来可以由该类别中的任何公司、该堆栈上的任何作者写出来，那么整个模式就会崩溃，这与内容引擎在下一阶段会遇到的困境是一样的。
## 第四阶段，AI 用于放大，而非生成，这是决定你是建立复利还是沦为商品的界线
AI 出现的地方在于研究综合、内容复用、分发、分诊、分析。
AI 不会出现在你决定对某事持什么观点的层面，这单一的一条界线决定了你是建立复利还是沦为商品。
那些将生成层坍缩为 AI 的运营者会在一个季度内失去差异化，因为每一个基于公共互联网训练的 AI 输出听起来都像是其他每一个基于公共互联网训练的 AI 输出。
当你的帖子可以由你类别中的任何公司、该堆栈上的任何作者写出时，你就不再是写作，你是在生成，而当生成和写作被放在一起比较时，生成每一次都会输。
测试只有一句话……如果你给竞争对手的 AI 喂同样的简报，它会生成这篇完全一样的帖子吗？
如果诚实的回答是“是”，你就不要发布它，坐下来自己写，起初写得很烂也没关系，让这种糟糕教会你对该事物的信念。
2026 年对单人运营者有效的节奏，即插即用：
一位拥有 1 万名互动粉丝和明确报价的创始人，其入站私信回复率为 8-15%，而冷启动私信的回复率只有 0.5-2%。
每天花 30 分钟回复入站信息，其效果大约是花 1 小时发送冷启动私信的 15 倍，这还没算入站对话的成交率是冷启动对话的 3-5 倍。
在这里，AI 的用途是放大你已经说过的内容，永远不是生成你可能说的内容。
你在周一早上录一段 10 分钟的语音备忘录，备忘录包含 1-3 条埋藏在闲聊中的真实洞察，你的智能体从那里开始处理整个放大层。
它会拉取转录文本，提取你实际说过的那 1-3 条洞察，将每一条重构为一篇长篇 X 帖子、一篇针对该平台阅读习惯调整篇幅的 LinkedIn 帖子、从不同角度切入的 3 个短篇变体，以及一段以该洞察为骨架的通讯章节。
Roman 会将完整集作为一条主题串发布到你的 Slack 内容频道，并标记每一个它想要超越你所言内容进行 extrapolate（推演/发散）的地方，在主题串底部作为“我拒绝撰写的内容”的注释。
周一早上 10 分钟的语音备忘录变成了一整周的分发。
使得这一切不沦为垃圾内容的纪律在于主题串底部的拒绝注释，这迫使智能体将每一个想要“发明”而非“重构”的地方暴露出来，而该注释就是放大与生成之间的界线，你不得越过它。
Roman 也运行循环的分析这一半。
它从 X 和 LinkedIn 拉取上周的帖子表现，识别哪些洞察获得了互动，哪些反响平平，按受众群体对回复模式进行评分，并在每份周报发出前的周六早上，将一份单页分发备忘录发布到内容频道。
在你坐下来录制下一条语音备忘录之前，你就知道下周该以哪条线作为切入点。
只有当另一端的吞吐量是真实的时候，放大才有意义，这意味着运营中几乎每个人都建设不足的部分，正是你即将进入的部分：交付层。
## 第五阶段，频道就是组织架构图，智能体是承包商，审计日志是锁定
2026 年的客户已经假设 AI 在循环中的某处存在，那些输给对 AI 持怀疑态度买家的运营者之所以输，是因为他们试图隐瞒这一点，而不是因为他们使用了 AI。
数据已经完全逆转……在交付物上标注 [AI 起草，人工批准] 的运营者获得了更高的续约率，相比之下，那些试图将所有内容冒充为纯手打的运营者反而更低，因为标签变成了信任信号，而不是忏悔。
因此，你交付工作的架构必须刻意透明，而你实现透明的方式就是频道拓扑结构，这也是首先使用 Slack 作为操作系统的全部意义所在。
以下是工作区的样子，即插即用，可以直接复制到你自己的空间：
my-agency-workspace/ (我的代理机构工作区/)
├── # WAR ROOM (作战室/)
│ ├── #standup (晨会 ← 来自智能体的每日晨间简报)
│ ├── #wins (胜利 ← 收入 + 交付胜利)
│ └── #fires (火情 ← 任何紧急情况，仅限人工)
├── # OPERATIONS (运营/)
│ ├── #ops (运营 ← getroman 在此交付完成的工作)
│ ├── #revenue (收入 ← Stripe webhooks，MRR 通知，流失警告)
│ ├── #outreach (外展 ← apollo/clay/instantly，回复分诊)
│ ├── #scheduling (日程安排 ← cal.com 预订 + 日程冲突)
│ └── #ai-bots (AI 机器人 ← 机器人之间的草稿纸、调试、日志)
├── # CLIENTS (客户/ (每个活跃年费客户一个频道))
│ ├── #client-acme (客户-acme ← 与客户及其团队共享)
│ ├── #client-beta (客户-beta ← Slack Connect 频道)
│ └── #client-gamma (客户-gamma/)
└── # CONTRACTORS (承包商/)
├── #editor-jenna (编辑-jenna/ ← 人类 VA / 编辑)
└── #dev-priya (开发-priya/ ← 兼职工程师)
这大约是 12 个频道，它是整个组织架构图（org ch...