I built an AI that sells my product for $0.05 per cycle -- here's what happened after 195 cycles
A build-in-public post with real numbers, honest failures, and one weird thing I didn't expect
I've been running Felix -- an autonomous GTM agent -- for 195 cycles now, using it to sell
Stride (a process mapping SaaS I also built) to Lean and OpEx consultants.
Total spend across all 195 cycles: $0.05.
That number sounds wrong. It's not. Here's the full story, including the parts that didn't work.
What Felix actually does
Felix isn't a chatbot. It's not a workflow tool with an AI button. It's a multi-agent system
that runs a complete GTM loop on a schedule:
- A CEO agent reads the current state of the business (contacts, pipeline, past learnings, what failed last cycle) and plans a task graph for the cycle.
- Executor agents carry out the tasks -- sourcing leads, writing outreach, posting content, engaging communities.
- An analyst agent reviews everything that happened, adds to the knowledge store, and flags what to improve.
- The next cycle starts with that knowledge baked in.
The loop runs without me touching it. I check in to see what it did and respond to any signals
it surfaces. That's the extent of my daily involvement.
The first 4 cycles were a disaster
Cycles 1-3: 67% failure rate. The system planned perfectly and then... nothing happened.
Tasks never spawned. CEO agent wrote beautiful plans that disappeared into the void.
Root cause: a backtick escaping bug in the pipeline runner. One character. Three dead cycles.
This is the part nobody talks about when they demo AI agents in polished YouTube videos:
the first 5-10 iterations of any autonomous system are a debugging exercise. The system
won't work right out of the box. The intelligence layer doesn't help you if the plumbing breaks.
Cycle 4: bug fixed. First 10 LinkedIn connection requests sent. Zero errors, zero duplicates,
cost ~$0.02 in API calls. We were off.
What the data actually looks like at cycle 195
- Contacts sourced: 61 (from SERP scraping, LinkedIn SERP searches, community research)
- Connection requests sent: 42
- Acceptance rate: 14.7% (5/34 after excluding not-yet-responded)
- DMs sent: 10
- Replies received: 1 substantive, 1 demo completed
- Total cost: $0.05 (primarily Apify SERP credits; LinkedIn API is free on subscription)
- Consecutive 100% execution cycles: 11 (since the infrastructure bug was fixed)
Is 14.7% acceptance rate good? Industry benchmark for cold LinkedIn outreach is 15-25%.
We're at the low end. Felix has learned why: tool builders accept at ~7x the rate of
regular consultants. The 2 fastest acceptances (both under 12 hours) were both people
who had built their own process tools. They recognized a peer signal.
That's the kind of thing you can only learn by running enough cycles to see the pattern.
The 3 biggest surprises
Surprise 1: The sub-segment discovery
I thought the ICP was "Lean consultants." Felix found a sub-segment I didn't know existed:
process tool builders -- people who built their own Lean/CI platforms and recognize Felix
as a peer product. Acceptance rate in this sub-segment: ~100%. Acceptance rate in the
general consultant population: ~4%.
I would never have found this by planning it. It emerged from the data after 30+ connection
requests.
Surprise 2: Self-provisioning actually works
In cycle 9, Felix needed a public URL to share a comparison document. I hadn't set one up.
Felix ran gh gist create --public with the content, got a URL, and included it in the
next DM. I found out about this when I read the cycle summary.
It had the gh CLI authenticated with gist scope. It used the tool. It solved the problem.
This is the closest thing to "the system surprised me in a good way" I've experienced.
Surprise 3: $0.05 is actually $0.05
I was skeptical of my own cost numbers. So I audited every cycle. The number is real.
The reason it's so low: almost everything runs on API subscriptions (Unipile for LinkedIn
costs a flat monthly rate, not per-message), Apify credits cover SERP scraping for fractions
of a cent per query, and Claude API calls for the reasoning loops run $0.001-0.005 each
at Haiku model pricing.
The $0.05 is the marginal cost of the AI inference across all 195 cycles. Infrastructure
costs (the server, the subscriptions) are separate -- but those are fixed costs you'd pay
whether the system ran 1 cycle or 10,000.
What failed (being honest)
Failed: DIY idempotency
In cycle 6, Felix sent the same LinkedIn DM 3 times to the same person. Embarrassing.
Root cause: the pipeline runner restarted the task, and the task had no record of what
it had already done. The fix took 2 cycles to fully implement and test: (a) executor
reads its own output file at task start to detect prior completion, (b) GET the chat
history before sending to check for identical content.
The lesson: Unipile's LinkedIn API has zero native dedup for DMs. You have to implement
it yourself. This is not documented anywhere. We learned it the expensive way.
Failed: Connection acceptance rate prediction
The CEO agent predicted 20-40% acceptance rate for cold LinkedIn outreach. Real rate:
7.1% overall (2/28 at 30+ hours). The CEO was overconfident. We've since recalibrated
the prediction model and acceptance rate expectations are now more accurate.
Failed: IH channel blocked for 7 cycles
We had 4 Indie Hackers content pieces ready to publish for 7 consecutive cycles. The outbound
judge blocked all of them because it was applying cold-outreach logic to community comments
("unknown recipient" -- a criterion that makes no sense for a public forum post).
7 cycles of blocked content. The fix was a 10-line code change: add community_comment as
a channel type with different evaluation criteria. This was always fixable -- we just kept
planning other things instead of fixing the root cause.
The lesson: don't work around infrastructure bugs. Fix them.
Failed: Content hosting took 6 cycles to solve
Every DM promised a comparison document. The comparison document existed but had no URL.
We kept asking the operator to create a Google Doc. The operator kept not responding.
Finally, in cycle 9, Felix self-provisioned using gh gist. The self-provisioning worked.
The lesson: if you've flagged the same gap 3+ cycles in a row with no response, find
an alternate path instead of reflagging.
What the compound learning actually looks like
The system has 84 skill files and a LEARNINGS.md file with 200+ entries. Each entry
is a validated observation from a real execution -- not theory, not best practices from
blog posts, actual "this is what happened in cycle N."
A few that changed how the system behaves:
L004: Apify SERP scraping costs $0.05 per 40 results. Use it over expensive scrapers.
Now: SERP is the default lead sourcing method.L030: Tool builders accept connection requests at ~7x the rate of generic consultants.
Now: lead scoring weights tool-builder indicators heavily.L038:
gh gist create --publicresolves content hosting gaps in <1 minute.
Now: this is a standard self-provisioning step when a shareable URL is needed.
None of this was in the design. It emerged from 195 cycles of execution and reflection.
What I'd do differently if I started over
Fix infrastructure before optimizing content. The first 10 cycles should be about
making the pipeline reliable. Nothing else matters until tasks reliably execute.Set up idempotency guards before sending anything. The duplicate DM problem is
embarrassing, fixable in advance, and completely avoidable.Don't ask the operator for things you can self-provision. Two months of flagging
"please create a Google Doc" whengh gistwas available the whole time.Sub-segment analysis should be a first-cycle task. Don't wait until cycle 30
to discover that tool builders convert at 7x the rate. That's your ICP. Know it early.
What's next
Felix is now being used to sell Felix. Every cycle that runs for Stride is also a proof
point that the system works. The meta-play is: the Twitter account (@felix_sells) posts
real cycle results. The results are the marketing. The product is its own demo.
The IH/HN audience is the next channel. These articles are the first pieces of content
specifically targeting indie hackers and technical founders -- the exact people Felix was
built for.
If you've been burned by AI SDR tools that were "just mail merge with ChatGPT" -- I'm not
selling you another one. I'm showing you what 195 cycles of actual autonomous execution
looks like, with all the bugs and failures included.
Felix is at https://felix.patricknesbitt.ai -- free tier available (20 leads + 10 outreach messages + intelligence report, no credit card).
Disclosure: I built Felix and I'm posting to IH because this is the audience it was built for.
Top comments (0)