$0/Month Agency: What Happens When Inference Is Free

I've spent the last few years building and deploying AI systems for small teams. I know the drill: you budget $50 here, $200 there for API credits, you watch your monthly burn rate climb, and you tell yourself it's the cost of doing business in 2025 — and in 2026, nothing's changed.

Then I came across a setup that forced me to rethink all of that.

A solo developer in Taiwan (Ultra Lab) runs his entire one-person agency on four specialized AI agents — content generation, social engagement, security monitoring, lead qualification — with a total monthly LLM cost of $0. Not "close to zero." Not "highly optimized." Zero. The entire stack runs on Gemini 2.5 Flash's free tier , which offers 1,500 requests per day at no charge.

The fleet handles ~105 automated tasks daily — publishing content, engaging on social, scanning for vulnerabilities, and qualifying leads — across platforms. The full playbook is open-sourced on GitHub with 80+ scripts, 25 systemd timers, and complete architecture docs. There's even a real-time agent dashboard showing the fleet in operation.

This isn't a clever hack. It's proof that the marginal cost of LLM inference is approaching zero for practical workloads. That changes the calculus for anyone building a micro-enterprise.

What Was Built

The fleet consists of four specialized agents coordinated by the OpenClaw gateway:

Each agent runs as a set of self-contained shell and JavaScript scripts, scheduled via 25 systemd timers on a single WSL2 Ubuntu instance. The hardware? A Windows desktop that was already running. No VPS. No Mac Mini. No cloud compute.

Most people don't picture this when they hear "AI agents." There's no persistent chat session. No long-running context window accumulating tokens. Each agent runs short, stateless tasks that read pre-computed intelligence files (19 .md files in total, automatically updated throughout the day), execute one focused LLM call, and complete.

Here's the full daily schedule from the playbook :

05:00  | research-chain → RESEARCH-NOTES.md
07:00  | autopost-probe (reads intel → quality gate → publish)
10:00  | autopost-advisor + engage × 4
11:00  | reply-checker (conversation management)
17:00  | research-chain (round 2) + daily-briefing
22:00  | post-stats → POST-PERFORMANCE.md
23:00  | reply-checker (round 2) + daily-reflect

The data flow is deliberate: upstream scripts produce intelligence files at 05:00, downstream autopost scripts consume them at 07:00. The intelligence layer costs zero LLM tokens — it's pure HTTP: RSS feeds via blogwatcher, HN API calls, URL summarization via Jina Reader.

The Pattern That Makes It Work

The core insight in this architecture is the short-task pattern. The playbook's blog post describes it directly:

Long conversation mode (most people): 20-turn conversation ~ 100 RPD, produces 1 result.
Short task mode (us): 1 task = 1 RPD, produces 1 result.

This is the architectural wedge that makes the free tier viable. Most users — myself included — open a chat session, go back and forth for 15–20 turns, and burn 100 requests on a single interaction. Ultra Lab's agents use ~7% of the daily free tier for 105 tasks, leaving 93% of quota unused.

This pattern has four properties:

1. Context is pre-computed. Performance data, competitor intel, research notes — all written to .md files by dedicated scripts. The agent reads them at execution time. No context window drift, no token waste on repetition.
2. Every request is self-contained. No dependency on conversation history. A timer fires, a script runs, a response is processed, the task ends.
3. Research steps cost nothing. RSS scanning, HN scraping, URL summarization — all HTTP. Only the final analytical step uses an LLM.
4. Failures are isolated. One timer failing doesn't cascade. A long conversation that errors mid-session burns the accumulated context.

The result is a 100x efficiency multiplier on the same API quota.

Where the Free Tier Bites Back

This architecture makes specific trade-offs, and they matter.

The system is cron-based with latency. If a customer sends an inquiry at 14:00, the lead-followup timer fires at 18:00. That's a four-hour window. For a real-time support desk, this doesn't work.

The free tier has a rate limit of 15 requests per minute. The reply-checker learned this the hard way — it once processed 33 accumulated comments in a single batch, hit the rate limit, and caused all other tasks to starve. The fix was to run more frequently with a cap of 5 replies per batch. The pitfall log in the playbook documents this and several other failure modes.

And then there's the billing trap. The developer burned $127.80 in 7 days by accidentally creating an API key from a billing-enabled Google Cloud project instead of AI Studio. I checked my own console the second I read that. The free tier caps rates and costs; the billing-enabled tier does not. Thinking tokens alone ($3.50/1M) can drain an account before you notice.

Key Lesson: Create Gemini API keys from AI Studio , not from a billing-enabled GCP project. The free tier's rate limits protect you.

These aren't dealbreakers, but they define what this architecture can and can't do. It's optimized for scheduled, asynchronous work — content pipelines, social management, research, lead qualification. It's not a replacement for interactive agents or real-time systems.

What $0 Inference Unlocks

This isn't really about Gemini's pricing. It's about what happens when inference costs fall below the noise floor of operational overhead.

At this agency's scale — 105 daily tasks across 4 agents — the LLM cost is zero. The only real expense is the electricity to run a WSL2 instance (~$5/month) plus the free Vercel hobby plan for the dashboard. The monthly cost breakdown confirms: everything else — Firestore, Telegram Bot API, Jina Reader, Moltbook API — has a free tier.

When inference is free, the bottleneck shifts. It's no longer "can I afford the API calls?" It's "can I design a system that uses calls efficiently?"

This flips the economics for solo founders, micro-agencies, and bootstrapped startups. A content marketing operation that would cost $100–500/month in API credits alone can now run for the cost of a laptop's electricity. The trade-off: this works only if you have the operational skill to run it — cron debugging, rate-limit handling, timer tuning are on you. The constraint moves from budget to architecture skill.

What You Can Steal From This Setup

Three patterns from this architecture are worth adopting, no matter which LLM you use:

1. Separate data gathering from reasoning. Use pure HTTP for the gathering layer. RSS, APIs, web scraping — these should never touch an LLM. Reserve model calls for synthesis and judgment.
2. Design for stateless execution. A timer-triggered script that reads state from files and writes results back is more reliable and debuggable than a persistent agent session. It also costs a fraction of the tokens.
3. Build intelligence files, not long prompts. Write performance data, competitor analysis, and research to structured files. Agents read them on demand. This decouples your data pipeline from your inference pipeline and makes both independently testable.

The GitHub repository contains the full implementation — scripts, timers, configuration examples, and a detailed pitfall log. It's MIT-licensed and actively maintained.

The agency model is not a toy. It's a production system running since March 2026, generating real engagement and leads. And it costs zero dollars in inference for the LLM layer.

That number — $0/month — is not the headline. The headline is that this is reproducible by anyone willing to invest in architecture rather than API credits.

Further Reading

1. Free Tier Agent Fleet — GitHub Repository — The full open-source playbook: 80+ scripts, 25 systemd timers, architecture docs, and pitfall log. MIT licensed.
2. Maxing Out the Free Tier: 105 Tasks on 1,500 RPD — The detailed blog post from Ultra Lab covering the six-layer enhancement architecture, RPD budget breakdown, and monthly cost analysis.
3. Ultra Lab Agent Dashboard — Live Demo — Real-time monitoring interface showing the fleet in operation with pixel-art virtual office visualization.