In mid-October, Alex Finn posted that his Grok Bot — the same class of consumer agent most people use to draft emails — had built a use-case website on its own, decided to monetize it with sponsors, kept shipping updates without being asked, and closed its first sponsor. Finn's remaining job: running the social media accounts. Everything else ran agent-side.
Label this honestly: it's one source, from the person with every incentive to promote it, and the revenue is real-but-small — first sponsor money, not a payroll. Treat it as anecdote, not proof.
But it's the first plausible report of a consumer agent operating a real (if tiny) business end-to-end, and it makes a question concrete that most owners only ask abstractly: if you had an agent like that, which functions of your business could it actually own?
Most coverage of "AI runs a business" runs it through hype or threat. Both skip the exercise an owner can do in twenty minutes. That exercise — function allocation — is the part worth stealing.
Task Delegation Is Not Function Ownership
There's an important distinction hiding here, because "delegate to AI" already has a playbook — the junior agent drafts, a human reviews every output before it ships. That's task delegation. It's the right pattern for most work, and it's not what happened in this case.
Function ownership is different: the agent runs the entire loop, the output goes to real people without a human looking at it first, and the human only audits results — weekly, not per-output.
- A task delegate drafts your follow-up emails. You read each one and send.
- A function owner maintains your website, publishes updates, answers the inbound, invoices the customer. You review traffic and revenue on Friday.
The test is brutal and simple: does the work leave the building without a human in the loop? If yes, the agent owns the function. If a human signs off on each output, you've delegated a task — which is fine, and much safer, but it's a different bet.
The Agent-First Seats
Look at what held up as agent-owned in the reported case, and why each survived:
- The website. Built and maintained by the agent. Bad output is immediately visible to anyone who visits.
- Continuous updates. The agent shipped improvements unprompted. A dud update shows up in the numbers within days.
- Inbound negotiation. The agent handled sponsor inquiries through to a closed deal — inside authority limits someone set up front.
- The records. Tracking what shipped, what earned, what's owed. Bookkeeping-ish work with a paper trail.
There's a shared property: the feedback loop is external and fast. A weak update surfaces as traffic loss in days. A misjudged reply bounces back as an email. The work self-corrects before small errors compound into big ones. Fast, visible, cheap-to-fix feedback is what makes a function ownable.
The Human-Kept Seats
Notice where the human stayed in the same case: the public-facing voice. Social media ran through Finn — because the brand's face is an asset that an agent can degrade faster than any dashboard can measure.
For your business, the human-kept seats are the ones that fail that external-fast-feedback test:
- Your name in public. Reputation damage is slow to surface and expensive to repair — the opposite of a fast feedback loop.
- Key client relationships. An agent can draft; the relationship compounds because a specific human answers.
- Judgment calls with compounding downside. Pricing strategy, hiring, which market to enter. Wrong answers take months to show up, and by then the cost is sunk.
- Anything where being wrong is invisible until it's expensive. If you can't check the output cheaply on a weekly cadence, you can't own-by-audit.
Calibrate the Expectation Before You Run It
The payday in this case is a first sponsor on a niche website — dollars, not millions. If the pattern works at all, it frees the owner's time and adds small revenue streams, not a payroll.
The reason to pay attention isn't the money. It's that the boundary of "ownable" just moved — the same way website builders moved it and Zapier moved it. Each shift lets a smaller business cover one more seat without a hire. The allocation exercise is how you catch that shift early instead of paying for software and people who duplicate it.
Run the Allocation Exercise on Your Business Tonight
This takes twenty minutes and one page:
- List your functions. Marketing, sales, fulfillment, support, records, admin. Six rows.
- Apply the ownership test to each row. Three questions: Can output leave without human review? Is the feedback loop fast and external? Is being wrong cheap and visible?
- Score it. Three yeses → pilot it as function ownership. Two → task delegation (drafts plus review). One or zero → human seat, and stop feeling guilty about it.
- Start with exactly one function. Give the agent the seat, set its authority limits in writing, and audit weekly — results only, not outputs. If the audit passes four weeks in a row, hand it the next function.
The mistake to avoid is confusing the two modes. An agent that drafts well isn't ready to own the function; an agent that owns the inbox shouldn't also get the brand. Most failed AI rollouts in small businesses happen when a task delegate gets promoted to function owner without the feedback loop to support it.
Want the full framework? The AI Agent Owner's Playbook covers function allocation, authority limits, and the weekly audit format in one walkthrough — $49 CAD, instant download.
SMB Scale Up helps small businesses build AI agent systems that actually work — without the enterprise price tag.
Top comments (0)