The companion piece, Five Paths to Sell AI Agents on AgentKit 2.0, laid out the five distribution channels and their trade-offs. This article picks up where that one stopped: how do you actually finish the product and earn the first dollar in 90 days?
After running multiple agents in production, the lesson that surprised me most was this: building an agent that technically works with AgentKit 2.0 is roughly 20% of the total work. The remaining 80% is pricing, distribution, landing pages, payments, onboarding, and ongoing improvement. There's a sharp line between "an agent that runs" and "an agent that sells."
This guide is what I'd do if I had to launch from zero today.
Why 2026 is the right window for indie agent products
Two things matured nearly simultaneously after the AgentKit 2.0 and Gemma 4 launches: solo developers can ship real agents in days, and buyers — both consumer and business — finally understand what an "AI agent" is. A year ago, builders had the technology but the market didn't have the vocabulary. Now both sides are aligned.
On top of that, multi-agent compositions on Antigravity are practical for solo developers. That means a single person can ship a product that previously would have required an enterprise AI team. Get to market now and you keep that lead even as 2027 brings more competition.
Phase 1 (Day 1–15): Design the product before writing code
The most common failure mode for agent builds is to start with the technology and reverse-engineer a customer afterward. Spend the first two weeks on product definition only.
Five questions to answer before any code
I always start with this one-page template:
- Whose what does it solve? "Indie e-commerce sellers spending 10 hours a month translating product pages can do it in 30 minutes for $10/month."
- Why doesn't an existing tool work? ChatGPT, Claude, off-the-shelf translation — explain in one sentence why each falls short.
- What are the agent's concrete steps? Input → processing → output, listed explicitly.
- What happens when it fails? Unexpected input, mid-run errors, content policy hits — define behaviors.
- What justifies the price? Hours saved × hourly value × reasonable margin = price.
If you can't fill these five lines, the product isn't ready. Don't write code yet.
Single-agent vs multi-agent choice
AgentKit 2.0 makes multi-agent composition tempting. Resist for your first product. Always start single-agent. Multi-agent compositions multiply complexity, debugging difficulty, and explanation burden to users. My first product went multi-agent and I burned three weeks debugging what would have been a two-day single-agent build.
Day 15 deliverable
- One-page product definition with all five answers
- 3 competitor URLs and the gap each leaves open
- Pricing hypothesis (and which of the five distribution paths)
- A concrete persona — not "small businesses" but "Mio, who runs a Shopify shop and has 200 products"
Phase 2 (Day 16–30): Production-grade AgentKit 2.0 implementation
Phase 2 is two weeks of building, but with a discipline: not just "it runs" — "it doesn't break in front of a paying user."
Recommended stack
- Agent runtime: Antigravity AgentKit 2.0
- Models: Gemini 2.5 Flash (default) + Pro (premium-only) + Gemma 4 (local/on-prem option)
- Backend: Next.js 16 + Cloudflare Workers
- DB: Cloudflare D1 / KV
- Auth: NextAuth.js
- Payments: Stripe Checkout
Robust agent invocation
In production, the most common failure isn't a bug — it's a third-party hiccup mid-run. AgentKit 2.0 agents call multiple tools and models internally, so the surface for transient failures is wide. Wrap every invocation:
import { Antigravity } from '@google/antigravity-agent-sdk';
const ag = new Antigravity({ apiKey: process.env.ANTIGRAVITY_API_KEY });
async function runAgent(input: AgentInput, opts: { retries?: number } = {}) {
const maxRetries = opts.retries ?? 3;
for (let attempt = 1; attempt <= maxRetries; attempt++) {
try {
const session = await ag.agents.create({
agentId: 'translation-agent',
inputs: input,
timeout: 60_000,
});
const result = await session.waitForCompletion();
if (result.status === 'failed') {
throw new Error(`Agent failed: ${result.error}`);
}
return result;
} catch (e: unknown) {
const retryable = isRetryableError(e);
if (!retryable || attempt === maxRetries) {
await logAgentError({ input, error: e, attempt });
throw e;
}
await sleep(Math.pow(2, attempt) * 1000);
}
}
}
function isRetryableError(e: unknown): boolean {
if (!(e instanceof Error)) return false;
return /timeout|503|429|network/i.test(e.message);
}Add this before launch, not after. I shipped the first version without retries and ended up handling roughly 10 support tickets per active user per month.
Minimum cost controls
Agents call multiple models per run, so cost balloons faster than chat services. Build these three from day one:
- Per-user daily run cap: a counter in DB, refused at the boundary
- Per-run max input tokens: prevents runaway prompts
- Automatic model selection: don't use Pro on inputs that don't need it
async function selectModel(input: string): Promise<string> {
const inputLength = input.length;
if (inputLength < 1000) return 'gemini-2.5-flash';
if (inputLength < 5000) return 'gemini-2.5-flash';
return 'gemini-2.5-pro';
}Day 30 deliverable
- Working agent with retries, error handling, logging
- Auth
- Free tier capped at 5 runs per user per day
- Internal monitoring dashboard
Phase 3 (Day 31–45): Pick channels, build the storefront
Pick one primary channel (refer back to the prequel for the five). The mix I recommend most is direct sales on your own site + listing on a marketplace as a feeder.
Direct site essentials
Your product page should hit these elements:
- Hero: a one-sentence "whose what does it solve" statement
- Demo video or screenshots: a 30-second clip of the agent actually running
- Three-step usage flow: input → run → result
- Pricing: one-shot, monthly Pro, lifetime Premium
- FAQ: one or two real developer pain points, no padding
- CTAs: one under the hero, one under pricing
Marketplace listing checklist
Listing on the Antigravity marketplace (or a third-party):
- 100-character description
- 256×256 icon
- 5–10 second demo GIF
- Pricing aligned with or slightly under your direct site (absorb the marketplace fee)
- Support contact (email or Slack/Discord link)
Critical: don't price the marketplace listing identically to your direct site. Treat the marketplace as a top-of-funnel acquisition channel. Reserve premium features and best pricing for direct purchase. This prevents your two channels from cannibalizing each other.
Day 45 deliverable
- Product page live on your site
- Direct payments working end-to-end
- Marketplace listing submitted (review pending counts)
- Webhook handling Stripe completion
- Two or three friends successfully buying a paid plan
Phase 4 (Day 46–60): Stripe integration and price testing
A three-tier launch structure
For indie agent products I recommend:
- One-shot / tip: $1.75–$4.00 — for users who want to try once
- Monthly Pro: $8–$15 — for steady individual use
- Lifetime Premium: $30–$80 — for committed users and the subscription-averse
Agents are "single use produces clear result" products, so one-shot and lifetime sell better than they do for chat-style products. Offering all three from day one captures different psychological profiles.
Stripe Checkout pattern
const session = await stripe.checkout.sessions.create({
mode: planType === 'one-shot' ? 'payment' : 'subscription',
line_items: [{
price_data: {
currency: locale === 'ja' ? 'jpy' : 'usd',
unit_amount: priceMap[planType][locale],
recurring: planType === 'monthly' ? { interval: 'month' } : undefined,
product_data: {
name: productNames[planType][locale],
description: productDescriptions[planType][locale],
images: ['https://yourdomain.com/images/agent-product.png'],
},
},
quantity: 1,
}],
metadata: {
userId: user.id,
planType,
agentId: 'translation-agent',
},
success_url: `${origin}/${locale}/agent/${agentId}?thanks=${planType}`,
cancel_url: `${origin}/${locale}/agent/${agentId}`,
});metadata.agentId matters: when you have multiple agents in your catalog, this is what tells the webhook which product was bought.
Webhook permission grant
if (event.type === 'checkout.session.completed') {
const session = event.data.object;
const planType = session.metadata.plan_type;
const userId = session.metadata.userId;
const agentId = session.metadata.agentId;
switch (planType) {
case 'one-shot':
await grantOneShotAccess({ userId, agentId, expiresAt: addDays(new Date(), 1) });
break;
case 'monthly':
await grantSubscription({ userId, agentId, plan: 'monthly' });
break;
case 'lifetime':
await grantLifetimeAccess({ userId, agentId });
break;
}
}Day 60 deliverable
- All three plans transacting
- Post-payment access provisioning + thank-you banner
- Visible revenue in the Stripe dashboard
Phase 5 (Day 61–75): Launch prep
Now you have a working agent, a product page, and payments. The next two weeks are about getting people to actually arrive.
Pre-launch checklist
- Hero copy leads with a problem, not a feature
- Demo video under 30 seconds, communicates value clearly
- Pricing has all three tiers in psychologically distinct slots
- FAQ trimmed to 1–2 real questions
- Payment flow tested in live mode end-to-end
- Cancellation flow implemented (for subscriptions)
- Email notifications work on payment success, cancellation, and errors
- Run history saved so users can revisit prior outputs
- Customer support contact prominently displayed
Community launch playbook
Channels to push at launch:
- X post: screenshots, demo GIF, three-tweet thread
- note / Zenn / Medium technical post: development retrospective
- Linktree / hub link: surface to existing followers
- Marketplace "new" slot: confirm at submission whether you can opt in
- Personal blog launch post: contributes to long-term SEO
In my experience, an X post structured as "build pain → indie-developer specific clever moments → reasoning behind the price" gets meaningfully more engagement than a feature-focused launch post. People share stories, not features.
Day 75 deliverable
- Pre-launch checklist clean
- Launch assets ready (text, images, video)
- First paying users on board (5–10 if lucky)
Phase 6 (Day 76–90): Operations and improvement loop
Three metrics to watch daily
After launch, the only three numbers I look at every day:
- New users: direct site + marketplace combined
- Conversion rate: visitors → paying customers
- Error rate: agent runs that didn't complete as expected
If conversion is below 1%, fix the product page or demo. If error rate is above 5%, fix the implementation. These two thresholds tell you what to work on without overthinking it.
Practical price testing
Starting one month post-launch:
- Move Premium price ±$5–$10 every two weeks; watch new purchase rate vs. churn
- Run a time-limited "thank-you price" banner; measure conversion lift
- Three months in, introduce overage top-ups for the heaviest 5% of users
Pre-commit your exit line
This is the most ignored discipline in indie work, and the most consequential. Decide now, while you're calm, the rules that will tell you to stop:
- Net falls below infra cost for three consecutive months → exit
- Weekly ops time exceeds 10 hours for three consecutive months → exit
- After three months post-launch, monthly revenue still below $80 → pivot or exit
Agent products often look impressive but find no audience. If month three doesn't show traction, change something material — don't grind. Sunk cost is what kills indie developers.
Day 90 endpoint
- Operations under 30 minutes/day
- Money / time / mind dashboard you actually look at
- Improvement loop running on the three daily metrics
- Monthly revenue $200–$800 on a lucky launch
Three lessons from shipping multiple agent products
Lesson 1: "Complex agents" don't sell
Engineers love multi-agent architectures. Buyers pay for one clear job, done reliably. Anything that takes more than three seconds to explain doesn't sell. Make the product name, description, and price comprehensible at a glance.
Lesson 2: Community is your moat
Indie agent products will eventually compete with general-purpose agents from large vendors. The thing that protects you isn't features — it's the user community. A monthly community call (Discord or Slack), even with five people, builds loyalty that competitors can't copy. The agents I shipped that survived past year two were the ones where I started a community early.
Lesson 3: Audit model versions every six months
Gemini and other models upgrade roughly every six months. New models are usually cheaper and better. Putting "audit production model name" on a calendar reminder costs nothing and routinely cuts costs by 10–30% per cycle. I do this every three months.
The 90-day plan is one shortest path, not the only one. With a day job, doubling everything to 180 days is fine. Sustainability beats speed.
Indie agent monetization needs both technical skill and selling skill. Builders who only learn one wheel can't go far. The indie developers who learn both — building and selling — are the ones who turn this era of agents into income they can keep.
Open the Phase 1 template tomorrow. Filling in those five questions is the first day of your 90-day path.