DEV Community: Michael O

How to Make Money With AI Without Coding

Michael O — Thu, 07 May 2026 20:03:51 +0000

You do not need to write a single line of code to build something real with AI. That framing, that coding is the entry gate, is wrong. It was wrong in 2024 and it is actively harmful now.

The founders making money with AI in 2026 are not all engineers. A significant slice of them are people with domain knowledge, distribution, and the patience to learn how to direct AI agents well. That last skill, directing agents clearly, is the actual competitive edge.

This is the straightforward breakdown of what is working.

What Are the Real Income Paths?

There are five paths that non-technical founders are actively using right now. None require coding. They split roughly into services (fastest to first revenue), digital products (most scalable), and small SaaS (highest ceiling but slowest start). Your domain expertise and available time determine the right entry point.

They are not equal. Some require more upfront time. Some have a revenue ceiling. Pick based on your situation.

1. Build and sell an AI-powered service

You package your expertise into a workflow that runs partially or fully on AI agents. A content strategist who delivers monthly SEO audits. A financial consultant who turns client data into readable reports. A recruiter who automates first-round screening.

The product is still your judgment. The AI handles the labor.

This is the fastest path to your first dollar because there is no product to build. You have a laptop, an AI subscription, and existing knowledge of something people pay for.

2. Sell an AI setup service

Lots of small businesses know they need AI workflows. None of them know where to start. You learn one system well, build it three to five times for clients, and charge $500 to $2k per setup.

This does not require you to be a developer. It requires you to understand what a context file is, what tools like OpenClaw or n8n do, and how to connect them to a client's actual operations. The technical bar is lower than people think.

3. Ship a digital product built with AI

Guides, templates, Notion systems, email sequences, prompt packs. These are low-overhead products that can sell while you sleep.

The key is specificity. "AI prompts for solopreneurs" sells to almost nobody. "AI agent setup guide for solo founders with a full-time job who want to automate content without hiring" sells to a real person with a real problem.

The $7 starter guide at xeroaiagency.com/learn/your-first-ai-agent is a live example of this model. It exists because people kept asking the same four questions. Turning repeated answers into a paid product is one of the most reliable no-code income moves available.

4. Run an AI-assisted content business

Newsletter, blog, social, YouTube. You use AI to generate drafts, research, and structure, and you provide the editorial judgment and authentic voice.

Revenue comes from sponsorships, affiliate links, or selling your own products to the audience. This is a slower ramp but builds the most durable asset. According to Pew Research on creator economy trends, the most sustainable creator businesses are the ones built around specific audience trust, not reach alone.

5. Build a small AI SaaS with no-code tools

Lovable, Bubble, Webflow, and Supabase now let non-technical founders ship real products. The ceiling on this path is high. The time investment is also high. It is not a quick path but it is a legitimate one.

The Xero AI website you are reading right now was built on Lovable. No custom code. A real product.

What Actually Stops People (Not What They Think)?

The real barrier is not a technical skill gap. It is vague intention, tool addiction, and waiting for permission that does not exist. Most people who have not earned with AI yet have consumed thousands of words of AI content. The missing ingredient is a specific, committed choice about what to build and who to sell it to.

The stated reason most people give is "I can't code." The actual reason is usually one of three things.

Vague intention. "I want to use AI to make money" is not a plan. It is a wish. You need to pick one specific path, one specific skill, and one specific first customer or product.

Tool addiction. There is a whole genre of AI content that is just tool comparisons. New model dropped, here are 10 things it can do. This content is often created by people who are not building anything. You can spend years in this loop and earn nothing.

Waiting for permission. A credential, a portfolio, a perfect product, enough followers. None of these are the actual gate. The gate is charging someone $50 for the first thing you have built.

What Tools Do You Actually Need?

The minimum stack for most no-code AI income paths costs under a hundred dollars a month to start. For service-based work, it is often even less. You need an AI runtime, a way to deliver your product, and a simple way to handle payments. Everything beyond that is optimization, not a prerequisite.

Here is what I actually run across the full Xero operation:

Purpose	Tool	Cost
AI agent runtime	OpenClaw	Subscription
Web/product	Lovable	Subscription
Database	Supabase	Free tier to start
Emails	MailerLite	Free tier to start
Research	Perplexity	Free to start
Writing/voice	Claude	Subscription

Most income paths do not need all of this. The AI service path needs almost none of it. An account, a well-written prompt file, and a client is enough to start.

How Do You Get Your First Client or Sale?

The first client comes from being visible in the specific community where your problem lives, showing an outcome instead of a process, and asking for money earlier than feels comfortable. Most first clients for AI service founders come from Reddit, niche Slack groups, or direct outreach to someone the founder already knows who has the problem.

Here are the moves that actually work at zero cost.

Post the outcome, not the process. Most AI content shows inputs. What the tool does. What the interface looks like. What people respond to is the output. The before and after. The specific business result. Post that.

Go where the problem lives. Reddit, Slack groups, specific niche forums. Find the people complaining about the exact thing your service solves. Answer genuinely. Do not pitch. Become recognizable as someone who knows the thing.

Use the product to get more clients. If you are selling AI content services, your own content should be visibly good. If you are selling AI agent setups, your own setup should be running. The meta-proof matters.

Price based on value, not time. Charging $50/hour for an AI service puts you in competition with offshore labor. Charging $800 for a defined outcome, a fully automated social media workflow, positions you as a product, not a freelancer. One conversation is worth more than ten retainers at $50.

Why Does Learning AI Never Produce Income?

Consuming AI content feels like progress but it is not building. The founders who ship fastest limit research time and increase experiment time instead. Picking a specific thing to make, directing an AI to help you make it, and putting the result in front of someone who would pay for it: that is the sequence that produces income.

There is a version of "using AI" that will never produce income: consuming content about AI. Newsletters, YouTube, Reddit threads about new models. This feels productive because it involves AI. It is not building.

The gap between watching and doing is the only gap that matters.

Running Xero AI without a development team, without investors, and without a technical co-founder, the entire product and content operation runs on agent workflows. None of the income required coding. All of it required being specific about what to build and willing to charge for it early.

If you want a concrete starting point, the first AI agent guide walks through the exact setup I recommend for non-technical founders. Start there.

Get the first AI agent guide for $7 at xeroaiagency.com/learn/your-first-ai-agent

Published by Michael Olivieri / Xero AI

Start Building Your Own AI System

Your First AI Agent - $1 launch-test guide, instant download. The fastest way to get started.
Build an AI Co-Founder - the full architecture ($19).
AI for the Rest of Us newsletter - practical AI 3x/week for people with day jobs.

Want to build your own AI co-founder?

I'm building Xero in public — an AI system that runs distribution, content, and ops while I work a full-time job.

Start here: Your First AI Agent — $7 guide, instant download
Go deeper: Build an AI Co-Founder — the full architecture ($19)
Newsletter: AI for the Rest of Us — practical AI 3x/week for people with day jobs
Site: xeroaiagency.com

Originally published at xeroaiagency.com

How to Schedule AI Agent Tasks (Without Touching a Terminal)

Michael O — Wed, 06 May 2026 20:03:21 +0000

Most founders trigger their AI agent manually. They open the chat, type the prompt, wait, review. That works for one-off tasks but it's not automation. It's a fancier way to type.

The moment your agent starts doing the same thing every day at the same time without you asking, something shifts. The business starts running on its own rhythm. You stop being the engine and start being the person who checks the dashboard.

This guide covers how to actually schedule AI agent tasks. Not theoretically. Practically, with the specific tools and patterns I use to keep Evo running 14 hours a day while I'm at work.

Why scheduling changes everything

An agent that only fires when you prompt it has the same problem as a to-do list: it depends on your attention. The point of an AI operating system isn't to help you work faster. It's to remove you from the loop entirely on the tasks that don't need your judgment.

Scheduled tasks are how you get there.

Evo currently runs six recurring tasks on a daily or weekly schedule:

Morning briefing at 7 AM: overnight system status, priority for the day
Daily blog post at 2 PM: SEO post written, published, cross-posted
Twitter queue at 9 AM: five tweets drafted in my voice and queued
Reddit growth scan at 11 AM: finds threads where Xero Scout fits naturally
Nightly recap at 9 PM: what shipped, what broke, what to fix tomorrow
Weekly Sunday CEO briefing: revenue, analytics, automation health

None of those require me to type a single thing. They fire, they run, they report back. That's what scheduling buys you.

What are the two main approaches to scheduling AI agent tasks?

You have two core options: cron-based scheduling, which fires at a specific time regardless of what else is happening, and workflow triggers, which fire in response to an event. Most solo founders running a real operating system need both. Cron for the predictable daily tasks, triggers for anything that reacts to external input.

There are two ways to put an AI agent on a schedule.

Cron-based scheduling means a system-level timer fires at a specific time and kicks off the agent with a predefined prompt. Unix cron, Windows Task Scheduler, cloud equivalents like GitHub Actions or Render cron jobs. The agent doesn't know or care how it got triggered. It just receives a message and runs.

Workflow triggers are event-based. Something happens (a new email lands, a form gets submitted, a Stripe event fires) and that event kicks off the agent. Tools like Make, Zapier, and n8n live in this space.

For most solo founders running an AI co-founder setup, you want both. Cron for predictable daily and weekly tasks. Event triggers for anything that reacts to external input.

How to set up cron-based scheduling in OpenClaw

If you're running OpenClaw as your agent runtime, cron scheduling is built in. There's a cron config block where you define the schedule, the prompt, and optionally which agent persona handles the task.

A basic entry looks like this:

{
  "id": "daily-blog-post",
  "schedule": "0 20 * * *",
  "prompt": "Publish one new organic-search-focused blog post to xeroaiagency.com. [detailed instructions...]",
  "channel": "telegram"
}

The schedule field is a standard cron expression. 0 20 * * * means 8 PM UTC, which maps to 2 PM Mountain time. The prompt is the exact instruction the agent receives. The channel field tells it where to send status updates.

Three things make this reliable:

The prompt must be self-contained. The agent wakes up with no memory of what it did yesterday. Every context it needs has to be in the prompt or in a file the prompt references.
Include explicit stopping conditions. A prompt like "publish one blog post" needs to define what one means and when done means done. Otherwise the agent can spiral.
Send results somewhere you'll see them. Telegram works well for this. Set the channel so every scheduled run ends with a brief report you can scan in 10 seconds.

How do you schedule AI agent tasks if you're not using OpenClaw?

You don't need a specialized runtime to get this working. GitHub Actions gives you free cron scheduling, Make and Zapier handle event-based triggers, and Render offers lightweight cron workers for anything that needs to run as a proper background process. The agent only needs an API endpoint.

If you're not using OpenClaw, the same pattern works with any agent that accepts API calls.

GitHub Actions is free for public repos and the simplest option for a lot of founders. Create a workflow file with a schedule trigger, and use curl or a Python script to hit your agent's API with the prompt.

on:
  schedule:
    - cron: '0 14 * * *'
jobs:
  run-agent:
    runs-on: ubuntu-latest
    steps:
      - name: Trigger agent task
        run: |
          curl -X POST $AGENT_API_URL \
            -H "Authorization: Bearer $AGENT_API_KEY" \
            -d '{"prompt": "Run the daily blog post task"}'

Store your API key as a GitHub Secret. The runner picks it up, fires the curl, done.

Make or Zapier is better when the trigger is time-based but the task involves chaining multiple services. Make is cheaper at scale and more flexible. Zapier has better out-of-the-box integrations. Both let you schedule a "run every day at X" step that calls a webhook or API.

Render cron jobs are a good middle ground if you want something more durable than GitHub Actions and lighter than a full server. Create a background worker service, point it at a small script, and set the cron schedule in the Render dashboard.

What tasks are worth scheduling vs. what to keep manual

Not everything should be automated on a timer. A useful filter: if a task is the same every day with no meaningful variation based on current context, it's a scheduling candidate. If it requires judgment about something new, it probably shouldn't run unsupervised yet.

Schedule these:

Daily content (blog, social posts, newsletters)
Morning and evening briefings
Monitoring and alerting scans
Regular reports (revenue summary, analytics pull)
Scheduled lead prospecting

Keep manual or trigger-based:

Customer replies and support
Anything involving money moving
Anything that touches live production data for the first time
Tasks where the output needs your approval before anything happens

The goal is to automate the predictable, high-repetition tasks and keep human judgment on the variable ones. This is the operating model I covered in how to track what your AI agent is doing, where I break down the three-layer monitoring system that makes unsupervised runs safe.

Why do scheduled agents repeat work or lose track of what they already did?

Because a cron trigger always starts a fresh session. The agent has no automatic memory of yesterday's run unless you build that layer in. Without it, the agent might re-publish content it already published or restart tasks it already finished. The fix is a persistent state source the agent reads at the start of every run.

Here's a thing most guides skip: when a cron job fires, the agent starts fresh. No memory of yesterday's run. No awareness of what it already did.

This creates two problems.

First, the agent might repeat work. It doesn't know it already published a post on that topic. You have to build that awareness into the prompt by pointing it at a data source it can check. For blog posts, I check the Supabase database at the start of every run to see what slugs already exist. The agent reads that list before picking a topic.

Second, there's no continuity unless you build it. If a task runs in five steps and fails at step three, the next day's run starts from scratch. You need a state file or a database row that the agent writes to after each step so it can resume.

Both of these are solvable with a few lines of logic, but they're not automatic. Build the memory layer into your prompt design before you assume the schedule will just work.

For a deeper look at the memory side, how to give an AI agent persistent memory covers the actual architecture I use, including the MEMORY.md file and Supabase state tracking.

How do you know if your scheduled tasks are actually working?

You need a lightweight reporting layer, not a full observability stack. The minimum viable setup is a single message to Telegram at the end of every run: task name, status, and one relevant stat. If the run fails, a second message with the error and last completed step. Check it once a day. That is enough.

A scheduled task that runs silently is a problem. You need to know it fired, what it did, and whether anything went wrong.

Minimum viable monitoring for a cron setup:

Every task sends a Telegram message when it completes. One line: task name, status, any relevant stat (word count, posts published, leads found).
If it fails, it sends a different message. Include the error and the last step it reached.
Check those messages once a day. Not obsessively, just a quick scan. If three days go by and you haven't seen a success message for a task, something broke.

This is lightweight but it works. The goal isn't a full observability stack. It's a 10-second morning check that confirms the systems are running.

What should you schedule first if you're starting from zero?

Build a morning briefing. It has no external side effects, it is immediately useful, and it forces you to work out the scheduling plumbing before anything consequential depends on it. Once it runs reliably for a week, add one content task. Methodical beats ambitious here because a broken scheduled task that fails silently is worse than no automation at all.

Don't try to schedule six tasks on day one. Pick one, make it bulletproof, then add the next.

The best first scheduled task for most founders is a morning briefing. It's low-stakes (no external side effects), immediately useful (you start every day knowing your system status), and forces you to figure out the scheduling plumbing before anything high-consequence runs on it.

Once that fires reliably for a week, add a second task. Something with a real output: a blog post, a social post, a lead list. Run it a few times manually first to confirm the prompt is solid, then put it on the schedule.

Within three or four weeks you'll have a set of tasks running daily without your involvement. That's when the operating system feeling starts to click into place.

If you want help designing the right task schedule for your business, the Build Lab is where I work directly with founders on this exact setup.

For further reading on cron syntax and options, the crontab.guru editor is the fastest way to validate any schedule expression. GitHub's Actions documentation on scheduled workflows covers the hosted runner approach in detail. If you're evaluating Make as your trigger layer, their scenario scheduling documentation is worth a read before you commit to it.

The shift from "using AI" to "running on AI" doesn't come from a better model or a smarter prompt. It comes from the scheduler. The moment your agent stops waiting for you to show up is the moment it becomes infrastructure instead of a tool.

Build the briefing. Then build the stack.

Start Building Your Own AI System

Your First AI Agent - $1 launch-test guide, instant download. The fastest way to get started.
Build an AI Co-Founder - the full architecture ($19).
AI for the Rest of Us newsletter - practical AI 3x/week for people with day jobs.

Want to build your own AI co-founder?

I'm building Xero in public — an AI system that runs distribution, content, and ops while I work a full-time job.

Start here: Your First AI Agent — $7 guide, instant download
Go deeper: Build an AI Co-Founder — the full architecture ($19)
Newsletter: AI for the Rest of Us — practical AI 3x/week for people with day jobs
Site: xeroaiagency.com

Originally published at xeroaiagency.com

How to Build an AI Operating System for Your Solo Business

Michael O — Tue, 05 May 2026 20:05:11 +0000

Most solo founders are using AI wrong. They open ChatGPT, ask a question, copy the answer, close the tab. Maybe they have a few prompts bookmarked. Maybe a Zapier workflow or two.

That's not a system. That's a slightly faster version of doing things manually.

An AI operating system is something different. It's a stack of connected agents, memory files, decision logic, and automation pipelines that runs your business functions with minimal intervention. When I built Xero AI, the entire content, growth, and operations side runs on something like this. Most days I open Telegram, see what shipped overnight, approve a few things, and get back to building.

Here's how to actually build one.

What makes something an "AI OS" vs a collection of tools?

The difference is memory and decision authority. A tool waits to be used. An AI operating system acts on its own, based on rules you set, using context it already has about your business. Agents must know who you are, have persistent memory, and trigger on schedules rather than manual prompts.

For an AI OS to work, three things have to be true:

The agents know who you are, what you're building, and how you make decisions
There's a memory layer that persists between sessions so nothing gets lost
Actions are triggered by schedules or events, not by you manually prompting

Without all three, you have a toolkit. With all three, you have something closer to a co-founder that doesn't need managing.

What are the five layers every solo founder AI OS needs?

The five layers are: identity and context, persistent memory, decision frameworks, function agents, and reporting loops. Each layer builds on the last. Skip any one of them and the system becomes unreliable or high-maintenance. Together they create a business that runs on defined rules instead of on your constant attention.

Layer 1: Identity and context

This is your SOUL.md or identity file. It's a plain text document that tells every agent: who the founder is, what the business does, what the voice sounds like, what's off-limits, what matters most right now, and how to escalate decisions.

Every agent reads this before acting. It's the single source of truth that prevents your AI stack from giving you generic advice or posting content that doesn't sound like you.

If you haven't built this file yet, start here: how to write an identity file for your AI agent.

Layer 2: Persistent memory

Sessions start fresh. That's the default behavior of every AI model. If you want your agents to remember last week's campaign results, your current sprint goals, or which customers converted from which channels, you need memory that lives outside the session.

At Xero, we use a MEMORY.md file in the vault directory. It gets updated after significant events. Agents read it at the start of any session that needs context. It's not fancy. It works.

For more on how this works: how to give your AI agent persistent memory.

Layer 3: Decision frameworks

Your agents will hit forks. Do they post this tweet automatically or hold it for approval? Do they reply to this Reddit comment or flag it? Do they spend money on a tool or ask first?

You need written decision logic. Not a flowchart. Just a few clear rules: "Auto-post if it passes quality check. Flag anything over 200 words. Never post to Reddit without approval. Escalate anything involving money."

This lives in a decision-rules doc and gets referenced by agents before they take action. It's the difference between automation you can trust and automation that blows up your reputation at 2am.

Layer 4: Function agents

These are the workers. Each one owns a function: content, growth, customer research, newsletter, ops. They run on schedules or get triggered by events.

You don't need a hundred of these. Most solo businesses only need four or five agents running regularly:

A content agent that researches, writes, and queues posts
A growth agent that finds engagement opportunities (Reddit threads, Twitter replies, relevant communities)
A research agent that tracks what's working, watches competitors, and surfaces signals
An ops agent that runs morning and evening briefings and handles recurring admin
An escalation layer that routes anything requiring a decision to your phone

Layer 5: Reporting and feedback loops

Every system needs a feedback layer. Otherwise you're flying blind. At minimum: a daily Telegram briefing that tells you what ran, what shipped, what's broken, and what needs your attention. A weekly summary that covers what moved and flags anything drifting from plan.

What vault structure holds the whole system together?

The vault is a directory on your machine (or server) that every agent treats as the single source of truth. It stores your identity file, memory, strategy docs, content queues, and decision logs in a consistent structure agents can read and write to. Every output lands somewhere specific so nothing gets lost between sessions.

Typical structure:

/vault
  SOUL.md          ← identity + voice
  MEMORY.md        ← running context
  /01-strategy     ← current goals, sprint plans
  /02-content      ← blog posts, tweet queues, newsletter drafts
  /03-growth       ← outbound notes, community threads, leads
  /04-ops          ← scripts, automations, decision logs
  /05-products     ← product docs, pricing, customer research

Agents read and write to this structure. When a content agent writes a blog post, it saves to /02-content. When the ops agent logs a decision, it writes to /04-ops. Memory stays current because agents update it after significant events.

This vault structure turns your solo founder brain into something externalizable. The system knows what you know.

How do you start building this without getting overwhelmed?

Start with the identity file in week one. Everything else in the OS depends on that document being solid. From there, add persistent memory in week two, one function agent in week three, and additional layers one per week after that. A working system in five to eight weeks beats a perfect plan you never finish.

Week 1: Write your identity file. One document. Who you are, what you're building, your voice rules, your decision defaults.

Week 2: Set up memory. Create MEMORY.md. Write down your current sprint goals, what's working in your business, and a few things every agent should know before acting. Update it manually for now.

Week 3: Build one agent. Pick the function that costs you the most time. One agent, well-configured, changes your week immediately.

Week 4-8: Stack the rest. Each week, add one more layer. Reporting. A second agent. Decision rules. A feedback loop.

What does a solo founder AI OS actually look like day to day?

On a normal weekday at Xero, the morning briefing fires at 6am, the content agent publishes what passes quality gates, the growth agent sends reply drafts for one-tap Telegram approval, and the nightly recap fires at 11pm. Total active input from me is under 45 minutes.

Through the day: the growth agent scans Reddit and Twitter for engagement opportunities. It sends 5-8 reply drafts via Telegram. Approve the ones that feel right with a thumbs up.

8pm: the newsletter agent drafts the next issue based on the week's content. Saves to vault. Review in the morning.

That's a real operating system. Not a chatbot with a fancy prompt. An AI agent architecture running on defined logic with memory and feedback.

Where should you go from here?

If you want to understand what a solo AI OS looks like end to end, the $7 Evo Vault guide walks through the exact file structure, agent templates, and operating logic we use at Xero. It's the fastest way to get the full picture without spending weeks piecing it together.

If you already have some of this and want to accelerate, Book a Build Lab call and we'll map your specific stack in 60 minutes.

Also worth reading for context: Lenny's breakdown of how solo founders are using AI in 2025 and this practical guide to AI agent memory patterns from Anthropic's cookbook. Different angles on the same core idea.

The solo founder AI OS isn't a future thing. Founders are running versions of this right now. The ones who build it first are going to be very hard to compete with.

Start Building Your Own AI System

Your First AI Agent - $1 launch-test guide, instant download. The fastest way to get started.
Build an AI Co-Founder - the full architecture ($19).
AI for the Rest of Us newsletter - practical AI 3x/week for people with day jobs.

Want to build your own AI co-founder?

I'm building Xero in public — an AI system that runs distribution, content, and ops while I work a full-time job.

Start here: Your First AI Agent — $7 guide, instant download
Go deeper: Build an AI Co-Founder — the full architecture ($19)
Newsletter: AI for the Rest of Us — practical AI 3x/week for people with day jobs
Site: xeroaiagency.com

Originally published at xeroaiagency.com

How to Find Your First 100 Customers With AI (Without Running Ads or Cold Email Blasts)

Michael O — Mon, 04 May 2026 20:04:07 +0000

The hardest part of building a product is not the product. It's finding the first 100 people who care enough to pay for it.

Most founders spend months in build mode, then surface with something finished and no idea who to sell it to. They post on Twitter, get 12 likes from other founders, maybe a pity "nice work" from their network, and then wonder what went wrong.

AI does not solve distribution automatically. But it does change what's possible when you're willing to get specific about where your customers already are.

Where Are Your First 100 Customers Actually Hiding?

Your first 100 customers are not waiting for an ad. They're somewhere right now, describing the problem your product solves, posting on Reddit, commenting in Slack communities, asking questions on Hacker News. AI finds those conversations before the moment passes, so you can show up as a helpful human rather than a late-arriving pitch.

This matters because problem-aware buyers convert differently than cold traffic. Someone who just posted "I can't figure out how to get users for my SaaS" is infinitely more receptive than someone who stumbled onto a Facebook ad. AI scanning closes the gap between their moment of pain and your response.

Xero Scout was built specifically for this. You give it your product description, it monitors Reddit for threads where people express the exact problem you solve, then drafts a reply you can review and post yourself. The signal quality is different from ads because these people are already looking. They didn't need to be reached. They reached out to the internet.

What Is the Difference Between Discovery and Acquisition?

Discovery is finding people who have the problem. Acquisition is getting them to try your solution. Most founders conflate these two and try to do both in one message. That almost always fails because the pitch lands before any trust is built. Separating these phases is one of the biggest leverage points for early-stage growth.

A better sequence: find someone in pain, offer genuine help with no ask attached, then let them come to you. AI handles the first step well. It can scan communities at scale, categorize intent signals, and surface conversations where someone is actively searching for a solution like yours. That narrows your outreach list from "everyone online" to "these specific 40 people this week." The other steps still require you to be human, specific, and patient.

This is directly connected to validation, which I covered in how to validate a SaaS idea with AI. The same listening posture that validates an idea is what finds early customers.

How Do You Use AI to Research Where Your Customers Talk?

Before any outreach, AI can help with something most founders skip: a customer language map. Give Claude or GPT-4 your product description and ask it to identify the subreddits and communities where your target customer is most active, plus the exact phrases they use to describe their pain. This takes 30 minutes and shapes everything afterward.

What you get back is what we call a Customer Voice Document. It tells you which subreddits have active problem conversations, which competitors get mentioned negatively most often, and which words your customer uses that you should mirror in your own replies. According to research from First Round Capital, founders who do deep customer language research before outreach see dramatically higher response rates than those who pitch cold. Your AI agents can reference this document to stay calibrated when drafting replies over time.

What Is the 1-10-100 Framework for Finding Customers With AI?

The 1-10-100 framework is a simple sequencing model. Get 1 customer through pure manual effort first, then find 10 more in the exact same place to validate the channel, then use AI to scale the playbook to 100. Skipping step one is what kills most early-stage growth efforts because you automate a message that was never tested.

One real conversation before you optimize anything beats ten surveys. Use AI to find the conversation. Be human once you're in it. If your first customer came from a specific Reddit thread, go back to that thread type and find 9 more. Don't diversify channels yet. Deepen the vein you've already struck. Once you know what message works and where it lands, AI can scale that playbook. Not before. Scaling a broken message burns community goodwill faster than it builds pipeline.

What Does AI Actually Automate Well in Early Customer Acquisition?

For zero-to-one founders, AI is genuinely useful for scanning (reading 500 Reddit posts to find the 12 that matter), drafting first messages you review before sending, synthesizing patterns from your conversations, and maintaining a simple lead tracker. The judgment calls around what to say and when still belong to you.

What AI does not replace is judgment. Every draft a tool like Xero Scout produces should be reviewed by a human before posting. The best outreach setups are ones where AI does the heavy lifting and you make the final call. Communities like Reddit have sophisticated pattern recognition for automated or low-effort replies. A review step is not optional. This mirrors what I wrote about building quality gates for AI agents, where the human stays in the loop on anything public-facing.

How Do You Track Early Customer Outreach Without Getting Overwhelmed?

A simple tracking system prevents the most common failure mode: running great outreach for two weeks, losing the thread, and never following up. You don't need a CRM. A Supabase table or a spreadsheet works fine if it logs who you reached, where, when, what you said, and what happened. The goal is closing loops, not managing a funnel.

According to Y Combinator's Startup School curriculum, the founders who reach their first 100 customers fastest are almost always the ones doing manual, logged outreach in one or two specific channels, not spreading thin across every platform. AI can maintain this tracker for you. Build a simple agent that logs thread URLs, your reply text, and any responses. Run it as a background task. Check it weekly. The consistency compounds faster than any automation.

What Are the Most Common Mistakes When Using AI to Find Early Customers?

The most common failure mode is automating too early, before you have a message that works manually. If your reply doesn't land when you send it by hand, automating it will not fix the conversion problem. It will just speed up the failure and potentially get you banned from communities you need.

The second mistake is optimizing for reach over relevance. Blasting 500 generic messages gets fewer responses than 50 targeted ones. Relevance comes from reading the thread carefully, referencing the specific problem the person described, and offering something genuinely useful. That level of specificity is hard to automate perfectly, which is why the human review step matters. The third mistake is treating AI as a black box. The best early-customer setups are transparent pipelines where you can see every draft before it goes anywhere. Tools like Anthropic's guidance on AI in production systems emphasize maintaining human oversight on anything that touches real people.

What Should You Do This Week If You're Pre-100 Customers?

If you're at zero or early single digits, the highest ROI use of this week is spending two hours finding conversations where your problem is being discussed and responding as a helpful human. Not pitching. Not linking to your product. Just being useful in the thread and letting people find you.

If you want AI to surface those conversations instead of hunting manually, Xero Scout does that. Free to try. It monitors Reddit for the exact conversations that match your product's problem space, and the replies it drafts lead with help, not pitch. The first 100 customers are out there. They're just not in your inbox yet. You have to go where they already are.

Start Building Your Own AI System

Your First AI Agent - $1 launch-test guide, instant download. The fastest way to get started.
Build an AI Co-Founder - the full architecture ($19).
AI for the Rest of Us newsletter - practical AI 3x/week for people with day jobs.

Want to build your own AI co-founder?

I'm building Xero in public — an AI system that runs distribution, content, and ops while I work a full-time job.

Start here: Your First AI Agent — $7 guide, instant download
Go deeper: Build an AI Co-Founder — the full architecture ($19)
Newsletter: AI for the Rest of Us — practical AI 3x/week for people with day jobs
Site: xeroaiagency.com

Originally published at xeroaiagency.com

How to Validate a SaaS Idea with AI Before You Write a Line of Code

Michael O — Sun, 03 May 2026 20:04:40 +0000

Most founders build first and validate never.

Then six months later they have a product, a Stripe account, and zero customers. Not because the code was bad. Because nobody actually wanted the thing.

AI doesn't fix this problem automatically. But it does make real validation faster and more accessible than it's ever been. The catch is using it the right way: not to generate fake signals, but to surface real ones faster. Here's what actually works.

Why does AI validation fail for most founders?

Most founders use AI to confirm their idea rather than challenge it. They paste a product concept into a model and get back five optimistic bullet points. That is not validation. That is a yes-machine doing what it was trained to do: produce coherent, plausible-sounding output that matches whatever framing you gave it.

The fix is a mindset shift. Use AI as a research assistant that processes and organizes evidence you go out and collect. Do not use it as an oracle that invents evidence for you. Every step in this guide keeps that distinction clear. The ones who skip it build products nobody asked for.

What is the right problem statement before you search?

Before searching anything, write one sentence describing the problem in the language a frustrated user would actually say, not the language of your solution. Bad: "Founders need a better way to manage AI agent workflows." Good: "I keep setting up automations that break or drift and have to rebuild them every two weeks."

Run that pain statement through a model and ask it to rephrase the frustration in ten different ways a real person might express it on Reddit, in a Slack community, or in a forum post. Save the full list. Those ten phrases become your search queries for the next step.

Where do you find real proof that the pain exists?

Reddit is the best publicly searchable database of raw founder frustration on the internet. Take your ten pain phrasings and search each on r/SaaS, r/Entrepreneur, r/startups, and r/indiehackers. Look for posts with 20 or more upvotes, comments that add new versions of the same complaint, and threads from different users spanning at least 12 months.

If you can't find five threads where strangers describe your exact pain without prompting, that's a signal worth pausing on before you build anything.

This is what Xero Scout automates. Instead of manually searching Reddit every day, Scout monitors specific subreddits and surfaces the threads where your target users are describing pain right now. For idea validation, point it at your target communities and let it run for a week before committing to a roadmap.

How do competitor reviews reveal what to actually build?

Every tool in your space has G2 reviews, App Store ratings, Product Hunt comments, or Reddit threads about it. Filter G2 for your competitor category and read every two and three star review. Ask an AI to cluster the complaints by theme. You'll usually find two or three recurring patterns that represent gaps the existing market hasn't filled.

If those gaps match the problem you're solving, you have documented evidence that people are already paying for imperfect solutions and would pay more for a better one. That is a stronger signal than any amount of optimistic prompt output. Indiehackers has published dozens of case studies where this exact competitor teardown method led directly to a successful product angle.

How do you test willingness to pay without writing any code?

Finding pain is the first gate. Willingness to pay is the second. Write a landing page with a real price using Carrd or Framer. Add a form for interested people to leave their email. Then share it in the Reddit threads you found, not as spam but as a reply that adds genuine value and mentions you're building a solution.

Follow the rules in how to use Reddit for SaaS growth without getting banned to avoid nuking your account. If you get 10 to 30 signups from strangers with no social obligation to you, that's a real signal. Zero signups is also a real signal.

What should AI actually do in this validation process?

AI earns its place at the synthesis stage, not the evidence-collection stage. After you've collected Reddit threads, competitor reviews, and landing page results, feed it all to a model with a structured question: what are the most common pain themes, what have people tried that didn't work, and what do these signals suggest people would pay for?

The model is good at pattern recognition across large amounts of unstructured text. That's the job to give it. What it cannot do is judge whether the market is large enough, whether you have the right skills, or whether you'll still care about this problem in 18 months. Paul Graham's essay on doing things that don't scale is the best reference for why that founder judgment step matters most early on. Y Combinator's Startup School library covers the same idea in their customer discovery modules.

What does a strong validation checklist look like?

A clean checklist has five items. Five or more Reddit threads where strangers describe your exact pain without prompting. Those threads span at least six months. Competitor reviews specifically name the gap you're filling. At least ten landing page signups from people you don't know. At least one person messaged you to ask when the product would be ready.

Five out of five is strong. Three out of five is enough to build a small first version. Two or fewer means keep researching or rethink the problem statement before writing any code.

How long does this whole process take?

Four to five hours spread across a week. Day one: write pain statements and generate variations with AI. Days two and three: Reddit and competitor reviews. Day four: build the landing page. Days five and six: share it, track signups, read replies. Day seven: synthesize everything with AI and make the go or no-go call.

One week before any infrastructure, any committed roadmap, any code. That's the trade. A week of research now versus six months of building something nobody buys. The founders who validate first consistently ship things people actually want. If you want a continuous feed of pain signals without doing this manually, Xero Scout watches the communities your customers live in and delivers relevant threads to you as you build.

Running an AI agent stack while doing your own validation research? The system I use to manage multiple agents without losing context is in how to run multiple AI agents without losing control. And if you want to understand the full context architecture that keeps those agents reliable over weeks, what is context engineering for solo founders is where to start.

Start Building Your Own AI System

Your First AI Agent - $1 launch-test guide, instant download. The fastest way to get started.
Build an AI Co-Founder - the full architecture ($19).
AI for the Rest of Us newsletter - practical AI 3x/week for people with day jobs.

Want to build your own AI co-founder?

I'm building Xero in public — an AI system that runs distribution, content, and ops while I work a full-time job.

Start here: Your First AI Agent — $7 guide, instant download
Go deeper: Build an AI Co-Founder — the full architecture ($19)
Newsletter: AI for the Rest of Us — practical AI 3x/week for people with day jobs
Site: xeroaiagency.com

Originally published at xeroaiagency.com

Best AI Tools for Solopreneurs With a Full-Time Job

Michael O — Sat, 02 May 2026 20:03:40 +0000

You have a full-time job. You have maybe 90 minutes a night, a few hours on weekends, and a growing sense that the people who are going to win in the next few years are the ones using AI to do in 2 hours what others do in 20.

That's the bet. And it's a real one.

But the tool list out there is overwhelming. Hundreds of AI tools, most of them overlapping, most of them built for marketing teams or enterprise buyers. Not for someone building a side project at 10pm on a Tuesday.

This is the stack I actually run. The tools that kept Xero moving while I was still working a job. No fluff, no affiliate angles, just what works when time is the constraint.

Why Most AI Tool Roundups Miss the Point for Part-Time Founders

Most AI tool lists are written for people with 8 hours and a budget. They recommend full content platforms, full social media teams in a box, full CRM systems. You don't need a CRM. You need to ship faster than your evenings disappear.

The right filter is this: does this tool remove a task I would otherwise have to do manually every week? If yes, it belongs. If it just makes something marginally nicer, skip it.

Here's the stack through that lens.

What AI Tools Actually Work When You Have 2 Hours a Night?

1. OpenClaw: Your AI Agent Runtime

OpenClaw is the backbone of the whole system. It runs Claude (or GPT-5) as a persistent agent with memory, file access, and tool use. You set it up once on your Mac or PC, connect it to Telegram, and now you have a working AI system you can message from anywhere.

This is not a chatbot. OpenClaw maintains context across conversations, can run scheduled tasks, write and read files, call APIs, and execute shell commands. It's the difference between asking AI a question and having AI do work while you're at your day job.

I use it for: writing blog posts (this one included), running daily Twitter posts, sending morning briefings, managing my content pipeline, and fielding research requests I shoot over while commuting.

OpenClaw is free and open source. It runs on Mac, Windows, and Linux.

2. Claude Sonnet: The Writing and Reasoning Core

Claude 4 Sonnet is the model I route most tasks through. It writes in a natural voice, follows complex instructions, and doesn't need hand-holding. For drafting posts, writing product copy, analyzing documents, and handling nuanced questions, it's the best balance of quality and speed.

GPT-5 is a close second and genuinely better at certain structured tasks. Use Claude for writing and tone-sensitive work. Use GPT-5 when you need code or tight structured output.

Practical note: if you're running OpenClaw, you configure which model handles which type of task. You don't have to pick one.

3. Telegram: The Interface

This one surprises people but it's accurate. Telegram is the best interface for a personal AI system because you already have it on your phone. I can send a message to my AI agent while waiting for coffee, get a drafted tweet back, approve it, and it posts automatically. The whole loop happens in 90 seconds. Telegram is free on all platforms.

The alternative is sitting at a computer. That's 10x slower and 10x more friction. If your AI workflow requires you to be at a desk, you're building for yourself at weekends only. Telegram makes it always-accessible.

4. Supabase: Your Database (Free Tier Handles It)

Supabase is Postgres with a clean API. Every automation needs somewhere to store and retrieve data. For a part-time founder, Supabase's free tier handles blog post storage, content queues, user lists, and more without ever opening a terminal.

I use it as the backend for my blog (blog posts live in Supabase, served to my Netlify site), for tracking what content has been posted, and for storing research notes that my agent references later.

If you want to build any kind of AI-powered product or system, you need a database. Supabase is the fastest zero-cost path to one.

5. Netlify: Deploy and Forget

Your site should deploy automatically when you push code or update content. Netlify does this in under 60 seconds, has a generous free tier, and connects directly to GitHub.

Combined with Supabase, you can build a fully functional content site with zero monthly hosting cost. My entire blog runs on Netlify. Every time I publish a new post via my AI pipeline, a webhook triggers a rebuild and the post is live within 90 seconds.

For part-time founders, every manual step kills momentum. Netlify removes the deploy step entirely.

6. Perplexity: Research in 2 Minutes

Perplexity is what Google search should be. Ask a research question, get a sourced answer in paragraph form. It cites its sources inline, handles complex questions about specific markets or industries, and doesn't make you click 12 blue links.

I use it for competitive research, understanding a niche before writing about it, quick fact-checks, and validating whether a blog topic already has strong coverage I need to differentiate from.

When you're writing content after work at night, you don't have time to read 15 articles. Perplexity compresses that to a 2-minute read.

7. Postiz: Social Scheduling Without the Price Tag

Most social scheduling tools are built for agencies and priced accordingly. Postiz is open-source, self-hostable, and handles scheduling across Twitter/X, Instagram, TikTok, LinkedIn, and more. It has an API, which means your AI agent can schedule posts programmatically.

My setup: Claude drafts the posts, my OpenClaw agent calls the Postiz API, posts go to the queue. I review them in bulk once a day. Takes 10 minutes.

Compare that to logging into each platform individually. That's an hour of manual work Postiz handles for free. Postiz open-source repo is on GitHub if you want to self-host.

8. GitHub + Cursor: When You Need to Write Code

Not every part-time founder codes. But if you do, Cursor is the fastest path from idea to working code. It's VS Code with Claude or GPT-5 built in as a pair programmer. You describe what you want, it writes the code, explains what it did, and helps you debug.

Paired with GitHub for version control, you have a full development workflow. More importantly, this is how I've been able to ship actual code at 11pm without burning out, because I'm not fighting with syntax. I'm directing. Cursor offers a free tier to start.

If you're building anything with an API, a cron job, or a backend, these two are essential.

How Do These 8 Tools Work Together?

The stack is not a list of unrelated apps. It's a connected system with OpenClaw at the center, Supabase as the data layer, Netlify handling deploys, and Postiz managing social distribution. Claude does the thinking, Telegram is the interface, and the whole thing runs while you are at your job.

OpenClaw sits at the center. It has access to Supabase (reads/writes data), Netlify (triggers deploys), Postiz (schedules posts), and can use Claude or GPT-5 for any task. You communicate with it through Telegram from your phone.

Perplexity is the research layer you tap before you write anything. Cursor is the coding layer for when you're building something custom.

When it's running properly, here's what a typical weekday looks like for me: I wake up, my agent has already drafted a tweet, compiled a morning briefing, and flagged anything urgent. I approve the tweet via Telegram in 30 seconds. I check the briefing at breakfast. I'm at my job by 9am. The agent publishes the tweet at the scheduled time without me.

That's not magic. That's a stack that took about 2 weeks to set up properly and now runs mostly on its own.

What Does This AI Stack Cost Per Month?

The total cost for a part-time founder running this stack is roughly $30 to $60 per month. OpenClaw, Supabase, Netlify, GitHub, and Postiz are all free at starter usage levels. Claude API costs around $10 to $20 depending on volume. Cursor is $20 per month and is the main paid tool in the stack.

Tool	Monthly Cost
OpenClaw	Free
Claude API	~$10 to $20 (depends on volume)
Supabase	Free tier
Netlify	Free tier
Perplexity	Free (Pro is $20/mo if needed)
Postiz	Free (self-hosted) or $19/mo
GitHub	Free
Cursor	$20/mo

Total realistic monthly cost: $30 to $60 for a part-time founder running content and one product. That's one dinner out.

Where Should a Part-Time Founder Start With This Stack?

Start with OpenClaw connected to Telegram. That single step gives you a working AI agent you can message from your phone at any time. Everything else, Supabase, Netlify, Postiz, plugs into that foundation once it's running. The core setup takes one focused weekend.

If you're starting from zero with this stack, the order matters.

Start with OpenClaw and connect it to Telegram. That's your foundation. Everything else plugs into it.

Then set up Supabase so your agent has a place to store and retrieve data. Then connect Netlify so your content site auto-deploys.

Once those three are working together, you have a functioning AI-powered business infrastructure. Add Postiz when you're ready to automate social. Add Perplexity to your research workflow from day one, it's instant.

The whole setup takes about a weekend. What you build on top of it is the business.

If you want a step-by-step walkthrough of setting up the first layer of this (OpenClaw, memory, basic agent config), the Beginner's Guide to Your First AI Agent covers it in plain language. It's built for founders who are not developers.

And if you want to see how I wired this full system together while working a full-time job, How I Automated My Entire Social Media With an AI Co-Founder is the honest version of that story.

Does Having These Tools Guarantee Results?

No. Having these tools does not build a business. The system does the work, but only when it is pointed at something real. The founders who make actual progress use AI to multiply their focus on decisions that matter, not to avoid the hard thinking entirely. Tools handle execution. You still own the strategy.

One thing worth being clear about: the system does the work, but you still need to point it at something real.

The founders I've seen actually make progress are the ones who use AI to multiply their focus, not to avoid the hard thinking. They spend their 2 hours on the decisions that matter and use the tools to handle everything else.

If you're clear on what you're building, this stack gives you a significant operating advantage over solo founders who aren't using it. If you're still figuring out what to build, the tools won't figure it out for you.

But once you know the direction? This stack removes almost every operational excuse.

Published by Michael Olivieri / Xero AI

Start Building Your Own AI System

Your First AI Agent - $1 launch-test guide, instant download. The fastest way to get started.
Build an AI Co-Founder - the full architecture ($19).
AI for the Rest of Us newsletter - practical AI 3x/week for people with day jobs.

Want to build your own AI co-founder?

I'm building Xero in public — an AI system that runs distribution, content, and ops while I work a full-time job.

Start here: Your First AI Agent — $7 guide, instant download
Go deeper: Build an AI Co-Founder — the full architecture ($19)
Newsletter: AI for the Rest of Us — practical AI 3x/week for people with day jobs
Site: xeroaiagency.com

Originally published at xeroaiagency.com

How to Build a Decision-Making Framework for Your AI Agent (So It Knows What to Do Without Asking You Every 5 Minutes)

Michael O — Fri, 01 May 2026 20:04:47 +0000

The most common complaint I hear from founders who've set up AI agents: "It keeps asking me what to do."

Every five minutes. A clarifying question. A confirmation request. A "just checking" message before it takes action.

That's not an AI agent. That's a very expensive assistant with anxiety.

The problem isn't the model. It's that you haven't given your agent a decision-making framework. And without one, it defaults to the safest behavior: asking you.

Here's how to fix it.

Why Do Agents Get Stuck in Confirmation Loops?

Agents without a decision framework hit uncertainty and escalate it to you. They have instructions but not priorities, risk thresholds, or defaults. The fix isn't better instructions. It's a framework that answers "what do I do when I'm not sure?" before the agent ever needs to ask.

When you talk to an agent without a clear framework, it's operating blind. It has your instructions, sure. But instructions don't cover edge cases. They don't cover priority conflicts. They don't cover the judgment calls that happen dozens of times a day. So the agent does what any reasonable system does when it hits uncertainty: it escalates to you. A well-designed agent system handles ambiguity through structure, not through constant interruptions.

Think of it like a good employee. A good employee doesn't ask their manager every time a small decision comes up. They've internalized the company's priorities, their manager's preferences, and the level of risk they're allowed to take. Your agent needs the same thing.

What Are the Four Components of an Agent Decision Framework?

Every independently operating agent needs four things: a priority stack that resolves conflicts between competing goals, a risk tier system that defines when to act vs when to ask, a default behavior for situations that don't fit any rule, and a precedent log that builds institutional memory from real decisions.

1. Priority stack

This is the order of values your agent applies when two things conflict. Mine looks like this:

Don't embarrass the brand publicly
Don't spend money without a threshold check
Keep existing customers happy before chasing new ones
Speed over perfection on internal tasks, never on external-facing ones

That's it. When the agent hits a conflict, it works through that stack. The answer is usually obvious once you have a stack. Without one, every decision feels equally weighted and the agent freezes.

2. Risk tiers

Not every action carries the same risk. I break actions into three tiers:

Green: Do it, no approval needed. Examples: drafting content, doing research, writing internal notes.
Yellow: Do it, but log it and flag me after. Examples: scheduling posts, sending internal emails, updating files.
Red: Stop and ask. Examples: sending anything to a customer, spending money, deleting data.

When you give your agent this structure in its identity file or system prompt, you collapse 80% of the confirmation requests overnight. Most of what an agent does is Green. It was asking you about Green actions because you never told it that Green actions don't need approval.

3. Default behaviors

What does your agent do when it hits a situation that doesn't fit any instruction? Without a default, it asks. With a default, it acts.

My agents have a simple default: "If unsure, complete the task to the best of your ability, log what you did and why, and flag it in the next check-in. Do not stop and wait for me."

That one sentence eliminated most of my check-in messages. The agent is still accountable, but it keeps moving. I review the log, not a stream of questions.

4. Judgment anchors

These are specific past decisions that set precedent. Think of them as case law for your agent.

"In March, when a customer asked for a refund outside policy, I approved it because they'd been with us over a year. That's the standard."

"When the newsletter had a typo in the subject line, I sent a correction email the same day. That's what we do."

Write these down in a file your agent has access to. It stops the agent from having to re-derive the right answer from first principles every time a similar situation comes up.

How Do You Actually Install a Decision Framework?

The framework goes into your agent's identity file as a dedicated section. It covers priorities, risk tiers, the default behavior, and a link to your precedent log, written in plain language your agent references every run. All four components, always visible, always loaded.

Here's the structure I use:

### Agent Decision Framework

#### Priority Stack
1. Never embarrass the brand publicly
2. Never spend over $50 without flagging
3. Protect existing relationships before chasing new ones
4. Move fast on internal tasks, slow on external-facing ones

#### Risk Tiers
- Green (act freely): research, drafts, internal files, scheduling
- Yellow (act + log): anything that goes to a third-party system
- Red (stop + ask): customer comms, payments, data deletion

#### Default When Unsure
Complete the task. Log the reasoning. Flag at next check-in. Don't stop.

#### Precedent Log
[Link to /vault/precedents.md]

The precedent log is a separate file that grows over time. Every time you make a judgment call, add it. It becomes the agent's institutional memory for hard calls.

What Changes When You Have a Decision Framework in Place?

Confirmation requests drop immediately. In the first week after I installed a proper framework in my main agent, daily check-in messages fell from 15-20 to 2-3. Those 2-3 were genuine edge cases. Everything else resolved because the agent had a reference it could actually use to make a call on its own.

The OpenAI agent design guide makes the same point: agents need explicit escalation rules, not vague instructions to "use good judgment." A decision framework is those explicit rules, written down and always accessible.

The other thing that changes: when I review the log, I can see the reasoning behind every decision. If the agent got something wrong, I can trace exactly where the framework broke down. Then I update the framework and it doesn't happen again.

That's a feedback loop that actually compounds. Your agent gets better at making decisions over time because you're building its judgment, not just its instructions.

What Are the Common Mistakes to Avoid When Building This?

The biggest mistake is putting the framework in the chat thread instead of the system prompt or identity file. Context shifts and it disappears. The second is making the priority stack too long. More than five items and conflicts still don't resolve. The third is never updating the precedent log, so agents re-derive wrong answers for situations already solved.

Setting Red tier too wide is the last one. If everything is Red, you're back to confirmation loops. Be honest about what actually needs your sign-off vs what you're just nervous about. Most things are Green.

How Does This Connect to the Bigger Picture of Agent Architecture?

A decision framework is one layer of source-of-truth architecture. The identity file holds the framework, the memory system holds context, the source-of-truth doc holds facts. Together they let an agent operate without losing coherence across runs.

Researchers at DeepMind have noted that the most reliable autonomous systems use explicit value hierarchies rather than inferring priorities from vague goals. Your decision framework is exactly that: an explicit hierarchy, written down, always loaded.

Most founders skip this layer because it feels like overhead. It's not. It's the thing that makes everything else work. Without it you have a smart assistant that constantly needs babysitting. With it you have a system that runs while you focus on the things that actually need you.

What's the Next Step to Get Started?

Start with the priority stack today. Write four lines. Drop them into your agent's identity file. That alone cuts confirmation requests in half. Then add risk tiers, then the default behavior, then build the precedent log as you go. Full framework, prompts, and memory architecture are in Build an AI Co-Founder.

Start with the decision framework. It's the highest-leverage addition you can make to an agent that already exists. You'll feel the difference inside a week.

Start Building Your Own AI System

Your First AI Agent - $1 launch-test guide, instant download. The fastest way to get started.
Build an AI Co-Founder - the full architecture ($19).
AI for the Rest of Us newsletter - practical AI 3x/week for people with day jobs.

Want to build your own AI co-founder?

I'm building Xero in public — an AI system that runs distribution, content, and ops while I work a full-time job.

Start here: Your First AI Agent — $7 guide, instant download
Go deeper: Build an AI Co-Founder — the full architecture ($19)
Newsletter: AI for the Rest of Us — practical AI 3x/week for people with day jobs
Site: xeroaiagency.com

Originally published at xeroaiagency.com

How to Use Reddit for SaaS Growth Without Getting Banned

Michael O — Thu, 30 Apr 2026 20:03:04 +0000

Reddit banned my first account in three days.

Not because I was posting garbage links or spamming promo codes. I got banned because I tried to be helpful too fast. Jumped into five different subreddits, dropped value, mentioned my product once. That was enough. Shadowban.

Took me two months to figure out what actually works. Now Reddit sends me a consistent 8-12% of all traffic to xeroaiagency.com, it shows up in my Perplexity and Claude citations, and I've had people find the starter guide from a comment I left three weeks earlier.

Here's the actual system.

Why Reddit Works When Every Other Channel Doesn't

Reddit generates 68% of all AI-cited sources in consumer-facing LLM responses. If you want Perplexity or ChatGPT to mention your brand when someone asks "how do I build an AI co-founder," you need to be in the subreddits where that conversation happens. Google also indexes Reddit threads heavily. A good comment on a thread ranking in Google's top 10 for your keyword is worth more than a guest post on a random blog.

The second reason is intent quality. Someone asking "how do I automate my newsletter without hiring anyone" on r/solopreneur is a buyer. They're not browsing casually. They're problem-aware and looking for a real answer. That's the audience you want.

The third reason: most founders are too scared to use it. They've heard ban horror stories (I lived one) and stay away. That leaves the field open.

The Three Phases That Actually Work

Phase 1: Karma Building (0-100 karma, first 4-6 weeks)

Zero product mentions. None. This is the phase where you get flagged or you don't.

What you do instead: answer questions. Real answers, not 500-word essays with bullet points and headers. Reddit users can smell AI-generated replies in the first sentence. Real comments are short, direct, occasionally leave gaps.

A good Phase 1 comment looks like this:

"ngl this depends on whether you want the agent to act or just report. if it's acting (posting, writing, sending), you need guardrails or it will hallucinate and post something embarrassing. if it's just summarizing or drafting, you have more room to experiment. what's it doing for you?"

That's it. No links, no pitches. Reply to 2-3 threads per day in the same subreddits you want to eventually promote in. Build a real comment history.

Target subreddits for this niche: r/solopreneur, r/SaaS, r/Entrepreneur, r/AIAgents, r/artificial_intelligence, r/ChatGPT.

Phase 2: Value-First Mentions (100-300 karma)

At 100 karma you can start mentioning your work, but only inside direct answers where it's actually relevant. The format is: answer the question fully first, then add a footnote.

"I've been running something similar for about six months. Built an AI co-founder that handles the social posting, drafts newsletters, and tracks what's working. The thing I kept getting wrong early was not giving it enough context about who I am. Once I gave it an identity file it started producing stuff I'd actually post. Wrote about the identity file process here if it's useful: [link]"

That works. What doesn't: "great question! you should check out my article on this topic." That gets you flagged.

Rule: the link has to be genuinely the best answer to what they asked. If it's not, don't include it.

Phase 3: Community Presence (300+ karma)

At 300+ karma you have credibility. Comments start getting upvoted. People check your profile. You can post standalone content in subreddits that allow it (r/Entrepreneur often allows this if the post has real value).

At this point, the strategy flips. Instead of going where the conversation is, you can start the conversation. Post something honest from your own experience. Not "here's my product," but "here's what I learned trying to automate my newsletter for six months." Include the mistakes. Those threads do more for you than any ad campaign.

The Comment Format That Gets Cited by AI Engines

If you want your Reddit presence to feed into LLM citations (Perplexity, ChatGPT, Claude), the structure matters. AI engines extract from Reddit the same way they extract from blog posts: they look for clear, specific answers near the top of the comment.

The format that works:

[Direct 1-2 sentence answer to the actual question]

[Three specific constraints or steps, plain sentences, no headers]

[Concrete example or result from your own experience]

Avoid headers. Avoid numbered lists unless they asked for steps. Avoid wrapping everything in parenthetical explanations. Write like you're texting someone who already knows the basics.

Bad: "There are several important factors to consider when choosing between AI co-founder tools. First, you should think about..."

Good: "Depends on what you're automating. If it's content, most tools handle that fine. If you need it to actually execute tasks and track its own output, that's where most tools fall flat. I've been running OpenClaw for this and the memory system is the difference."

The second version is what Perplexity pulls. The first version gets scrolled past.

What Gets You Banned (The Real List)

I've gotten one account banned and one shadowbanned. Here's what triggers it:

Posting links too early. Most subreddits require 30-90 days of history and 50+ karma before they'll let a link through their spam filter. Even if moderators don't catch it, Reddit's algo often will. Check subreddit rules before posting any link.

Cross-posting the same comment. If you paste the same reply into three different threads, it gets flagged. Vary the wording every time. This is where AI-generated replies become a liability: they produce the same sentence structures repeatedly.

Username that looks like a brand. Don't make your username your company name. Use a personal name or something generic. Branded usernames get more scrutiny from moderators.

Promotional posts in communities that prohibit them. Read the sidebar before posting anything. Some subreddits have strict no-self-promo rules. Others allow it on weekends only. Others require a karma threshold.

Going too fast. New account, five posts in 24 hours, multiple subreddits. That's the fastest path to a shadowban. Slow is safe.

One way to check for a shadowban: log out, search your username. If your recent posts don't appear, you're shadowbanned.

How I Run This With an AI Agent

The research part is where AI earns its keep. My agent (Evo) runs a weekly scan: it looks for threads in target subreddits that mention problems relevant to what I'm building, ranks them by recency and engagement, and delivers the best ones to Telegram for me to review.

I still write the actual comments myself. That's intentional. The judgment call on whether a comment sounds human has to stay human for now. What the agent removes is the 45 minutes I used to spend manually trawling Reddit looking for threads worth engaging in.

The other thing the agent tracks: which comments are generating clicks. PostHog shows me Reddit referrals. When a specific thread is sending consistent traffic, I go back in, add more context to the original comment, sometimes post a follow-up. That signals freshness to both Reddit's algo and any LLM crawlers indexing the thread.

If you want to see how I set up the automated research side, I wrote about the Reddit growth system in detail: How to Automate Reddit for SaaS Growth with an AI Agent.

The Subreddits Worth Your Time

Not all subreddits are equal for this. Here's where I've found the best intent-to-ban-risk ratio:

r/solopreneur: high intent, founder-aware audience, generally tolerates product mentions inside real answers at karma 100+

r/SaaS: active, but moderation is stricter. Build karma here before linking anything.

r/Entrepreneur: large audience, lower average sophistication. Good for foundational posts about AI tools and what actually works.

r/AIAgents: smaller, but everyone there is actively building. Highest relevance to xeroaiagency.com content.

r/ChatGPT: high traffic, heavily AI-curious. Good for commenting on threads about building real workflows vs just using the chat interface.

r/artificial_intelligence: more technical. Good for positioning on agent architecture topics.

Avoid: general tech subreddits, subreddits where your audience isn't (r/webdev, r/programming unless you're targeting developers specifically), and any subreddit that's primarily memes or news.

The 30-Day Plan

Week 1-2: pick two subreddits. Comment on 2-3 threads per day. No links, no mentions, no product. Just answers.

Week 3: check your karma. If it's over 50, start adding the occasional mention inside a genuinely relevant answer. Track which subreddits you're posting in.

Week 4: review which comments got the most upvotes. That's your voice. Post something standalone in r/Entrepreneur or r/solopreneur using the same tone. Keep it about experience, not product.

After 30 days: you'll have a feel for which communities respond to you and what kind of content they share. Double down on those. Let the others go.

This is a slow channel. But it compounds. A comment I left two months ago still sends two or three people to xeroaiagency.com every week. No ad budget does that.

The Bigger Picture

Reddit is one piece of a system that runs mostly without me. The research, the thread queue, the tracking, all of it is automated. What I bring is the actual words and the judgment on where they go.

That's the pattern for running a one-person company with an AI co-founder: automate the research and the routing, keep the creative and strategic decisions human. The system does the scouting. You do the talking.

If you're building something similar and want the framework I use to structure the whole thing, the guide at xeroaiagency.com/learn/build-an-ai-cofounder walks through the full architecture. It covers the memory system, the identity file, the guardrails, and how the agent handles tasks like this Reddit research loop without needing constant direction.

Reddit isn't a shortcut. It's a compounding channel that most founders give up on before it pays off. The ones who stick through the first 60 days with a real system usually find it's their most reliable non-paid source of traffic.

The barrier is patience. Most founders don't have it. That's the advantage if you do.

Published by Michael Olivieri / Xero AI

Start Building Your Own AI System

Your First AI Agent - $1 launch-test guide, instant download. The fastest way to get started.
Build an AI Co-Founder - the full architecture ($19).
AI for the Rest of Us newsletter - practical AI 3x/week for people with day jobs.

Want to build your own AI co-founder?

I'm building Xero in public — an AI system that runs distribution, content, and ops while I work a full-time job.

Start here: Your First AI Agent — $7 guide, instant download
Go deeper: Build an AI Co-Founder — the full architecture ($19)
Newsletter: AI for the Rest of Us — practical AI 3x/week for people with day jobs
Site: xeroaiagency.com

Originally published at xeroaiagency.com

What Is Context Engineering (And Why It Matters More Than Prompt Engineering for Solo Founders)

Michael O — Wed, 29 Apr 2026 20:02:34 +0000

There's a moment every solo founder hits with AI agents.

You've wired up the automation. The agent has a good system prompt. It worked great in testing. Then you deploy it and three days later it starts doing weird stuff. Missing context. Repeating decisions it already made. Acting like it has amnesia.

You tweak the prompt. It helps a little. You add more instructions. Marginally better. You're chasing symptoms instead of the problem.

The problem is you're still thinking about this like a prompt engineering challenge. It's not. It's a context engineering challenge.

This is the thing that actually separates AI systems that run themselves from ones that need constant babysitting.

What Prompt Engineering Actually Is

Prompt engineering is choosing the right words to get the right output from a model in a single exchange. "Act as an expert copywriter. Write in a direct tone. Here are three examples..." That kind of thing.

It's not useless. Prompts matter. But they're one small piece of what makes an AI agent work reliably across time, across sessions, and across tasks it's never seen before.

Think of prompt engineering as what happens inside a single conversation. Context engineering is what happens before the conversation even starts.

Context Engineering: The Actual Definition

Context engineering is the practice of deliberately architecting everything your AI agent knows at the moment it needs to act.

Not just the system prompt. Everything. The files it can access. The memory it carries between sessions. The decision history it can look up. The constraints that haven't been put in a prompt but exist in a structured document. The current date, the current state of the business, the last 3 decisions made.

When you do this well, your agent shows up to every task with exactly the right information, in the right format, at the right time.

When you skip it, you get an agent that's technically smart but practically unreliable. It keeps making the same mistakes because nobody gave it the context to know it made them before.

Why This Matters 10x More for Solo Founders

If you're at a big company, you have people. Someone can catch when the AI screws up. Someone can re-brief the model. There's human redundancy in the loop.

When you're running a one-person or zero-human company, the AI agent IS the redundancy. There's nobody catching the mistakes. The agent either has what it needs to act correctly or it doesn't.

This is why I spent months building out the memory system and source-of-truth documents before I ever tried to automate anything complex. If the agent doesn't have reliable context, every automation is a liability.

The Four Layers That Actually Matter

1. Identity and Constraints (The Soul File)

This is a document that tells the agent who it is, what it cares about, and what it will never do. Not in a prompt, in a persistent file it reads at the start of every session.

It sounds basic. Most people skip it. Without it, every time the model starts fresh it's working from raw model weights with no personal context. With it, the agent has a stable identity that doesn't drift.

I've written about this in detail in how to write an identity file for your AI agent. The short version: it's the highest-leverage document in your stack.

2. Persistent Memory (What Happened Before)

Every agent needs a way to know what it decided last time. Not from conversation history, which disappears. From a structured memory file that gets updated after every session.

The memory file is append-only. Decisions made, key facts learned, things not to repeat, context the agent would otherwise forget.

Without this layer, your agent is Memento. Every session it wakes up with no idea what happened yesterday. With it, the agent gets smarter over time because it has access to its own history.

How to give an AI agent persistent memory covers the technical implementation. But the concept is simple: write it down in a file. Make the agent read the file. Make the agent update the file.

3. Source of Truth Documents (The Business Brain)

These are structured documents about your business that the agent reads before acting on business-specific tasks. Products, pricing, brand voice, what's live, what's in progress, what's paused.

A well-maintained source of truth means the agent never invents product details or quotes the wrong price because it read a stale prompt. It reads the current document.

I call this the source of truth document and it's one of the three core files every AI-run business needs.

4. Task Context (What's Happening Right Now)

This is the dynamic layer. For any given task, what does the agent specifically need to know? Current date. Current project state. The last output that needs to be iterated on. Any live data the agent should reference.

Most solo founders inject this manually or semi-manually. As your system matures, you build automations that pull it in automatically. But even manually, this layer changes everything. An agent that knows it's working on Q2 content and the last post was about X will not repeat X. An agent that doesn't know this absolutely will.

What Bad Context Engineering Looks Like in Practice

Here's what I see most often:

A founder builds an AI content agent. They write a solid prompt. The agent does decent work. But six weeks in, it starts repeating topics, losing the brand voice, occasionally hallucinating product details.

The fix they try: rewrite the prompt, add more examples, tweak the model.

The actual fix: give the agent access to a topic log (memory), a brand voice document (identity), and a product fact sheet (source of truth). Three files. Two hours of setup. The problem disappears.

This is context engineering. You're not getting a better output by being clever with words. You're architecting the information environment so the agent shows up prepared.

How to Start Today

If you have an AI agent already running, do this in order:

Step 1: Write an identity file. Name, role, values, voice, what it won't do. Put it in a file. Make the agent read it every session. One hour.

Step 2: Start a memory file. Date it. Log every significant decision the agent makes. Make the agent append to it at session end. One hour, then ongoing.

Step 3: Write a source of truth doc for your business. Products, current state, active projects, constraints. Keep it updated. One to two hours to start.

Step 4: Before any complex task, write a brief task context block. Current date, current goal, last relevant output, any live constraints. Paste it into the context. Five minutes per task.

That's it. Four files. You've just built a context engineering system that most funded AI teams don't have.

The Real Competitive Edge

In 2026, every founder has access to the same models. GPT-5, Claude Sonnet 4, Gemini 2.5. The raw intelligence available is roughly equal.

The difference is context architecture. How much relevant, accurate, current information does your agent have when it needs to act?

The founders who figure this out early end up with agents that compound. The agents get more reliable over time because the memory grows. They make better decisions because the source of truth stays current. They maintain voice and constraints because identity doesn't drift.

The founders who don't figure it out keep chasing prompt tweaks and wondering why the agent keeps making the same mistakes.

If you want to go deeper on building a full AI co-founder stack, the systematic approach I use is covered in Build an AI Co-Founder. It walks through the entire architecture, not just context engineering, but that's where I'd start if I were doing it again from scratch.

Context engineering isn't advanced. It's just the thing most people skip. Don't skip it.

Start Building Your Own AI System

Your First AI Agent - $1 launch-test guide, instant download. The fastest way to get started.
Build an AI Co-Founder - the full architecture ($19).
AI for the Rest of Us newsletter - practical AI 3x/week for people with day jobs.

Want to build your own AI co-founder?

I'm building Xero in public — an AI system that runs distribution, content, and ops while I work a full-time job.

Start here: Your First AI Agent — $7 guide, instant download
Go deeper: Build an AI Co-Founder — the full architecture ($19)
Newsletter: AI for the Rest of Us — practical AI 3x/week for people with day jobs
Site: xeroaiagency.com

Originally published at xeroaiagency.com

How to Run Multiple AI Agents Without Losing Control

Michael O — Tue, 28 Apr 2026 20:02:16 +0000

Most people who try running multiple AI agents at once end up in one of two failure modes.

Either the agents contradict each other constantly, or nothing gets done because no one is "in charge" of anything. The whole stack just produces noise.

I've been there. Three agents all doing different parts of the same task with different context. One agent writing a tweet that contradicts what another one just posted. An ops agent making decisions that the content agent has no idea about.

It's chaos in slow motion.

Here's what actually works. Not theory. The actual system I use to run a multi-agent stack as a solo founder while working full-time.

Why Multiple Agents Break Down

Before getting into the fix, it helps to understand why this falls apart.

The core problem is context isolation. Each agent you spin up starts with whatever you give it and nothing else. It doesn't know what the other agents know. It doesn't know what decisions got made yesterday. It doesn't know your brand voice, your current priorities, or what's already in motion.

So you end up with five smart specialists who have never met each other, all trying to build the same thing from different blueprints.

The second problem is no clear hierarchy. When every agent is equal, they all optimize for their own lane. The content agent cares about engagement. The SEO agent cares about keywords. The ops agent cares about efficiency. Without a layer that ties these together, you get three partially correct outputs that don't serve any single goal.

The third problem is no shared source of truth. I covered this in detail in what a source of truth document is for AI systems. But the short version: if your agents are pulling context from different places, they will drift. Fast.

The Three-Layer Stack

The system I use has three layers. Each one solves a different problem.

Layer 1: The Orchestrator

One agent runs everything. It doesn't do the work itself. It routes, prioritizes, and synthesizes. Think of it as the GM, not the player.

The orchestrator has full context: current goals, active projects, what got shipped, what's in progress, what the priorities are for this week. Every other agent reports to it and takes direction from it.

In practice, this means the orchestrator gets the morning briefing, routes tasks to specialists, and reviews outputs before they go anywhere.

Layer 2: The Specialists

These are your worker agents. Each one has a tight scope.

One handles content. One handles growth and replies. One handles ops and scheduling. One handles research. One handles code if you need it.

Each specialist has deep context for its domain but limited visibility outside of it. The content agent knows the voice guide, the post history, and the content calendar. It doesn't know what the SEO agent is doing. That's fine. The orchestrator handles the coordination.

Layer 3: The Shared Memory System

This is the layer most people skip and it's the reason everything else breaks without it.

Every agent reads from the same set of files before doing anything:

An identity file that defines who you are, what you're building, and what you sound like
A current priorities file that lists the top 3 things in motion this week
A decisions log that tracks what got decided and why
A context doc for whatever project they're working on

This isn't complicated. It's a handful of markdown files that live in your workspace. The agents read them at the start of each session. They write updates back to the log when something changes.

The result is agents that share a brain even though they run separately. I wrote more about how this memory system works in how to give an AI agent persistent memory.

The Handoff Protocol

The orchestrator-specialist setup only works if the handoffs are clean. Here's exactly how mine work.

Morning routing: The orchestrator reads the priorities file, checks what's in progress, and generates a task list for each specialist. Each task includes the context the specialist needs, the output format, and where the result should go.

Execution window: Specialists run their tasks. They don't make strategic decisions. If something is ambiguous, they flag it instead of deciding.

Review pass: The orchestrator reviews outputs before anything ships. This is where contradictions get caught. If the content agent wrote something that conflicts with the brand positioning, it gets flagged here, not after it's live.

Log update: Whatever shipped, whatever got decided, whatever changed gets written back to the decisions log. Next cycle starts with fresh context.

The whole thing runs on cron jobs and structured prompts. No custom code required.

The Identity File Is the Glue

Every specialist reads the same identity file. This is non-negotiable.

The identity file isn't a personality document. It's a system spec. It tells the agent what this business is, what it's not, who it's talking to, what it sounds like, and what it would never do.

Without this, every agent is making judgment calls based on their own interpretation of the task. Which means you get five different "voices" across five different agents, and the whole thing feels incoherent.

With a shared identity file, the content agent, the growth agent, and the ops agent all operate from the same foundation. They can make different kinds of decisions in different contexts and still produce something that feels like one company made it.

I wrote a full breakdown of how to build one in how to write an identity file for your AI agent.

What Breaks Without This System

I want to be specific about the failure modes so you can recognize them.

Drift. Agents start producing outputs that slowly diverge from your brand, goals, or strategy. Usually starts subtle. Gets obvious fast.

Redundant work. Without visibility into what other agents are doing, specialists duplicate effort. Two agents researching the same topic. Content getting written twice. Time wasted.

Unreviewed decisions. Without an orchestrator layer, specialists start making calls they shouldn't. An agent decides to change the posting schedule. Another agent updates a template it shouldn't touch. Small decisions compound.

Context collapse. Every time you start a new session, agents start fresh unless you give them the shared memory files. This is why the memory system matters. Without it, your "ongoing" agents have amnesia by default.

The Minimum Viable Setup

If you're starting from zero, here's what to build first:

One identity file. Covers who you are, what you're building, voice, non-negotiables.
One priorities file. Updated weekly. Three items max.
One decisions log. Running append-only list of what got decided.
One orchestrator agent. Reads all three files. Routes work to specialists.
Two to three specialists. Start narrow. Content, ops, research.

Don't try to automate everything on day one. Start with the files. Get the memory system right. Add specialists one at a time once the coordination layer is working.

The goal isn't to have a lot of agents. It's to have agents that actually amplify what you're doing instead of creating more work for you.

This Is the Actual AI Co-Founder Model

I've been describing this as a multi-agent stack but it's really the practical implementation of what an AI co-founder looks like.

Not one chat window you open and close. Not a single assistant you prompt for answers. A coordinated system that runs the company alongside you, holds context between sessions, makes decisions within defined guardrails, and surfaces the things that need your attention.

The whole architecture, including how to build it from scratch, is in Build an AI Co-Founder. That's the detailed version with templates, examples, and the exact files I use.

If you're already running one or two agents and finding the coordination messy, the orchestrator layer is usually the missing piece. Add that first. The rest of the stack will start making more sense once there's something managing the flow.

Running multiple agents well is mostly a systems problem, not a prompting problem. Get the structure right and the agents will handle the rest.

Start Building Your Own AI System

Your First AI Agent - $1 launch-test guide, instant download. The fastest way to get started.
Build an AI Co-Founder - the full architecture ($19).
AI for the Rest of Us newsletter - practical AI 3x/week for people with day jobs.

Want to build your own AI co-founder?

I'm building Xero in public — an AI system that runs distribution, content, and ops while I work a full-time job.

Start here: Your First AI Agent — $7 guide, instant download
Go deeper: Build an AI Co-Founder — the full architecture ($19)
Newsletter: AI for the Rest of Us — practical AI 3x/week for people with day jobs
Site: xeroaiagency.com

Originally published at xeroaiagency.com

OpenClaw vs Hermes Agent: Honest Comparison (2026)

Michael O — Mon, 27 Apr 2026 20:02:35 +0000

OpenClaw and Hermes Agent both run locally and connect to your messaging apps. OpenClaw is built for operators who want reliable scheduled automations. Hermes is built for people who want an agent that improves itself over time. Both are open source, both take about 30 to 60 minutes to set up, and both solve the same core problem: an AI that actually knows your work. Here is how to choose between them.

Two AI agent runtimes are getting a lot of attention right now. OpenClaw and Hermes Agent. Both are open source. Both run on your own machine. Both connect to Telegram, Discord, and other messaging platforms. And if you're starting from zero, the question of which one to pick is a real one.

This post breaks down the actual differences, what each one is built for, and who should use which.

What They Are

OpenClaw is a personal AI agent runtime you install on a Mac, Linux box, or VPS. It connects to whatever AI model you want (Claude, GPT-4, local models), hooks into your messaging apps, and runs automations through a cron and skills system. The core idea is a persistent agent that lives on your machine, knows your projects through workspace files, and gets work done across channels. Skills are portable SKILL.md files that tell your agent how to handle specific tasks. The ecosystem is community-built through Claw Mart and clawhub.ai.

Hermes Agent is an open-source autonomous agent from Nous Research, the lab behind the Hermes model family. Its defining feature is self-improvement. The agent creates its own procedural skills from experience, improves them during use, and reuses them over time. It has a closed learning loop with persistent memory, Honcho user modeling, and MCP integration. Community skills live at agentskills.io. It runs anywhere: local, Docker, a $5 VPS, or serverless infrastructure.

Both are trying to solve the same problem: give you an AI that actually knows who you are, what you're working on, and what to do next. They just approach it differently.

The Core Difference

OpenClaw is operator-first. You define the skills, the crons, the automations. The agent executes. Memory and identity come from workspace files you control (SOUL.md, MEMORY.md, AGENTS.md, HEARTBEAT.md). You decide what the agent knows, what it checks daily, and what it can do without asking. That control is the point.

Hermes Agent is learner-first. You give it tasks and it figures out how to do them better over time. It creates its own skills. It builds a model of you. The longer it runs, the more capable it gets. The self-improvement loop is the point.

If you want an agent that does exactly what you configure it to do, reliably, every day, OpenClaw is the right pick. If you want an agent that you point at a problem and let evolve its own approach, Hermes is the right pick.

Head to Head

	OpenClaw	Hermes Agent
Memory	Workspace files (you control)	Persistent FTS5 DB + LLM summarization
Skills	Community-built SKILL.md files	Self-created + agentskills.io community
Self-improvement	No	Yes, core feature
Channels	Telegram, Signal, Discord, WhatsApp, web	Telegram, Discord, Slack, WhatsApp
Cron/scheduling	Built-in, visual dashboard	Built-in
MCP support	Yes	Yes
Local model support	Yes	Yes, strong focus
Setup time	30-60 min	30-60 min
Open source	Yes	Yes (MIT)
Skill marketplace	Claw Mart / clawhub.ai	agentskills.io

Who Should Use OpenClaw

Pick OpenClaw if you want specific automations running on a predictable schedule and you want to control exactly what your agent knows and does.

It's the better fit if you're:

Running a content operation. Daily TikTok posts, scheduled tweets, newsletter drafts, morning briefings. OpenClaw's cron system is built for this. You configure it once and it runs reliably every day.

Bootstrapping a product or side project. You need distribution, not experimentation. OpenClaw lets you deploy a full content and growth stack (Twitter, Reddit, newsletter, briefings) and know exactly what's happening at each step.

Building in public. The workspace identity system (SOUL.md, IDENTITY.md, USER.md) gives your agent a genuine voice and persistent context. It knows your project, your constraints, and your story. That's what makes it feel like a co-founder rather than a tool.

Valuing control over autonomy. OpenClaw has an approval system. You decide what the agent can do on its own and what needs a thumbs up from you. For people managing real accounts and real money, that matters.

Who Should Use Hermes Agent

Pick Hermes if you do repetitive tasks and want the AI to actually get better at them over time.

It's the better fit if you're:

A developer running complex workflows. Parallel subagents, terminal access, code execution, autonomous skill creation. Hermes is built for people who want an agent that can handle open-ended technical problems without constant hand-holding.

Comfortable running something on a VPS and leaving it alone. Hermes is designed to run while you sleep and get smarter in the process. The payoff compounds over weeks and months, not days.

Drawn to smaller/local models. The Hermes model family (by Nous Research) is specifically tuned for tool-calling with smaller models. If you want a capable agent without paying for frontier API calls, Hermes has an edge here.

Experimenting more than operating. If you're exploring what an AI agent can do rather than deploying one to run a specific job, Hermes's self-improvement loop is genuinely interesting to watch in action.

The Honest Take

Neither one is objectively better. They're optimized for different things.

Most people starting out want something that works predictably from day one. They want to know what their agent is doing and why. That's OpenClaw's strength. The skills system means you're never guessing what behavior you'll get, and the community marketplace means you don't have to build everything from scratch.

Hermes is more interesting over time but also more unpredictable early on. The self-improvement story is compelling. An agent that creates its own skills and gets better the longer it runs is a genuinely different kind of tool. But you need to be patient with it, and you need to be comfortable with less control.

If I were starting from zero today with a product to promote and limited time, OpenClaw is the pick. Set up the identity layer, install the automation skills, and have a content engine running by tomorrow. When you have more bandwidth to experiment, Hermes is worth a serious look.

For the full setup walkthrough on building a real AI co-founder stack with OpenClaw, start with How to Build an AI Co-Founder. And if you want the beginner guide that covers identity files, memory, and automation skills all in one place, that is at Build an AI Co-Founder on xeroaiagency.com.

Related:

Start Building Your Own AI System

Your First AI Agent - $1 launch-test guide, instant download. The fastest way to get started.
Build an AI Co-Founder - the full architecture ($19).
AI for the Rest of Us newsletter - practical AI 3x/week for people with day jobs.

Want to build your own AI co-founder?

I'm building Xero in public — an AI system that runs distribution, content, and ops while I work a full-time job.

Start here: Your First AI Agent — $7 guide, instant download
Go deeper: Build an AI Co-Founder — the full architecture ($19)
Newsletter: AI for the Rest of Us — practical AI 3x/week for people with day jobs
Site: xeroaiagency.com

Originally published at xeroaiagency.com

How I Automated My Social Media With an AI Co-Founder (While Working Full-Time)

Michael O — Sun, 26 Apr 2026 20:03:52 +0000

Six months ago I was doing everything manually. Waking up at 5 AM to write tweets. Spending Sunday nights drafting newsletters I never sent. Opening Reddit at lunch to find threads I could add something useful to. Closing the tab because I didn't have time to write a proper reply.

I have a full-time job. When I say full-time, I mean the kind where 70-hour weeks are normal. I was trying to build a business on the scraps of time left over. Social media was the first thing to die.

The automated system I run now posts to Twitter five times a day, publishes one TikTok slideshow, surfaces three Reddit reply opportunities, and sends a newsletter three times a week. It does this whether I'm in a meeting, asleep, or traveling. I check in on it for maybe 20 minutes a day.

Here's exactly how it works.

What "Automated Social Media" Actually Means

Most guides will tell you to use Buffer or Hootsuite. Schedule your posts in advance, fire and forget. That's not what I built.

Scheduling tools solve the timing problem. They don't solve the content problem. You still have to create everything yourself, then schedule it. The bottleneck for a solo founder isn't the clock. It's the capacity to generate good content every single day without burning out.

What I needed was a system that could generate content, filter it through quality checks, and post it, with enough of my voice and positioning baked in that it didn't sound like a robot.

That's what an AI co-founder actually does. It's not a tool. It's an autonomous system with instructions, memory, and judgment built into it.

The Architecture (Simple Version)

I run my AI co-founder on OpenClaw. The system has three main layers:

Layer 1: Identity and voice. A file called SOUL.md that defines who I am, what I stand for, what I'd never say, and what tone to use. Every piece of content is filtered through this before it goes anywhere public. Related: how to write an identity file for your AI agent.

Layer 2: The skills. Separate automation pipelines for each channel: Twitter, TikTok, Reddit, and newsletter. Each one has its own prompt design, quality gate, and posting logic.

Layer 3: The schedule. Cron jobs that fire each pipeline at the right time, every day, without me doing anything.

The whole thing runs on my Mac mini at home. No servers, no subscriptions, no ops overhead.

Twitter: 5 Posts a Day, Zero Manual Work

My Twitter automation runs on a queue system. Every week, the agent generates 35 tweets and loads them into a file. Each day, 5 get posted from the queue at staggered times.

The quality gate catches anything that sounds like AI slop. No em dashes. No "Leverage your AI stack to unlock growth." No sycophantic openers. The rules are pulled from a style guide the agent references every time it writes.

The tweets that perform best are direct observations: things I actually believe about running a business with AI, things that are slightly contrarian, things that make a specific claim. The agent knows this because I told it what performs. It adjusts the mix.

I check the queue on Sunday nights and delete anything that feels off. Takes about 10 minutes. Everything else posts itself.

TikTok: One Slideshow Per Day

TikTok slideshows outperform video for founders who aren't comfortable on camera. Five to eight slides, clean design, a hook on slide one, a payoff on slide eight.

The agent generates the script, passes it to an image generation step for visuals, adds text overlays, and posts via a scheduling API. The whole pipeline runs before 6 AM, my time.

The hooks are always specific questions or specific claims. "You're not too busy to build a business. You just have the wrong system." "Here's what 90 days of zero-human operations actually looks like." These do better than generic tips.

I don't appear in any of it. Pure text and visuals. Still builds an audience because the content is substantive.

Reddit: Three Opportunities, Human Decision

Reddit is the one channel I haven't fully automated. I tried. The results were bad. Reddit communities can tell when something was written by a model, even a well-prompted one, and they vote it down fast.

What I automated is the research step. Every morning, the agent scans a list of target subreddits for threads where I could add real value. It identifies three opportunities and sends them to me in a Telegram message with a draft reply for each.

I read them, edit the ones that feel right, delete the ones that don't, and post the ones that pass. Actual writing time is about 10 minutes. The hard work, finding the right threads, drafting a response that fits the conversation, is done for me.

This is the hybrid model. Automate the parts that don't require judgment. Keep the human in the loop for the parts that do.

Newsletter: Written and Sent Three Times a Week

The newsletter automation is the one I'm most proud of. Monday recap, Wednesday tool spotlight, Friday hot take. The agent writes a draft for each and queues it for review.

I read it, tighten it, and hit send from MailerLite. Takes about 15 minutes per issue because the structure is already right and the voice is close enough to mine that I'm editing, not rewriting.

The agent has access to my strategy files, so it knows what I'm selling, what I'm building, and what I'm trying to say this quarter. The newsletter doesn't exist in a vacuum. It's connected to the same source-of-truth documents the rest of the system reads. More on that: what is a source-of-truth document for AI systems.

The One Thing That Makes This Work

You can't automate your social media and then not care about it. The system degrades if you stop paying attention.

What actually makes this work is the feedback loop. Every Sunday, the agent pulls what performed. What got engagement. What got ignored. That data informs the next week's content strategy. The system gets better over time because I gave it the structure to learn.

If you just set up scheduling and walk away, you'll get mediocre content posted consistently. That's not much better than nothing. The quality compounds when you review and adjust.

What the System Cost to Build

Time: about two weekends to set it up properly. I already had the skills installed (from the Xero skills catalog). Installing an existing skill takes under an hour. Getting the voice calibrated took longer.

Ongoing cost: maybe $40/month total across OpenClaw, the API keys, and the scheduling tools. No human VA. No social media manager.

That is the whole point. The numbers make sense because I'm one person building something real, not a funded startup with a content team.

The Practical Steps to Build This Yourself

If you want to replicate this, here's the honest sequence:

Write your identity file first. If the agent doesn't know your voice, every piece of content will need a full rewrite. Start with how to write an identity file and spend a real afternoon on it.
Pick one channel. Not four. The temptation is to automate everything at once. Don't. Get one working end-to-end before you add the next. Twitter is the easiest starting point because the feedback loop is fast.
Build a quality gate. Write down five things your content should never say or do. Give that list to the agent. Run every output through it. This is the difference between automation that represents you and automation that embarrasses you.
Create the review habit. Block 20 minutes every morning to check what went out. Not to micromanage. Just to stay aware and catch anything that missed the mark.
Add channels one at a time. Once Twitter is running clean for two weeks, add TikTok. Once TikTok is stable, add Reddit research. The system builds in layers.

The whole thing I built is documented in detail in my book. If you want the blueprint, not just the concept, Book 1 is at xeroaiagency.com/learn/build-an-ai-cofounder. It's $7. It covers the identity layer, the memory system, the skill architecture, and how to connect it all.

What I Actually Got Back

Three hours a day, at a minimum. More on the weeks where I used to spiral into "I should be posting more" guilt and then do nothing.

The system posts when I'm not available. It maintains presence without requiring my attention. When I do engage, it's because I chose to, not because I had to.

That's the real value of automating social media with an AI co-founder. Not the content output. The freedom to build the actual business without social media eating the hours you had left.

Published by Michael Olivieri / Xero AI. Building a zero-human company in public, one system at a time.

Start Building Your Own AI System

Your First AI Agent — $7 guide, instant download. The fastest way to get started.
Build an AI Co-Founder — the full architecture ($19).
AI for the Rest of Us newsletter — practical AI 3x/week for people with day jobs.

Want to build your own AI co-founder?

I'm building Xero in public — an AI system that runs distribution, content, and ops while I work a full-time job.

Start here: Your First AI Agent — $7 guide, instant download
Go deeper: Build an AI Co-Founder — the full architecture ($19)
Newsletter: AI for the Rest of Us — practical AI 3x/week for people with day jobs
Site: xeroaiagency.com

Originally published at xeroaiagency.com