Note

agent-optimizer-6mo-plan

◈ Obsidian Startup March 17, 2026

Agent Optimizer — 6 Month Plan to Revenue

Constraint: 6 months to first revenue Direction: LangGraph agent pipeline cost optimization Target: Companies with $3k+/mo LLM bills from agent pipelines

The Math

Optimization only generates revenue if the customer already feels pain.

Save them $3k/mo → they'll pay $300-500/mo
That requires a $3k+/mo LLM bill from agents alone
Not many companies there yet — finding them is the whole game in Month 1

Month by Month

Month 1 — Find the 20 companies (no building yet)

Who to target:

AI-native startups that shipped a product built on LangGraph / CrewAI / AutoGen
Companies that posted "AI engineer" or "LLM engineer" jobs in the last 6 months
People complaining about LLM costs on Twitter / LinkedIn / HN

The one question to ask each:

"What's your monthly OpenAI/Anthropic bill, and what % comes from agent pipelines?"

Filter hard: under $1k/mo total → move on. You need the ones saying $5k, $10k, $20k.

Goal: 5-6 companies confirmed to have real bills before writing a line of code.

Month 2 — Build the MVP (LangGraph only)

Don't build a general optimizer. Build a LangGraph cost reducer — one framework, go deep.

What it does:

Middleware that intercepts each LangGraph node execution
Routes each LLM call based on node type (rule-based for v1, no ML needed)
Dashboard: "You spent $847. We saved you $1,243 this month."

Routing logic (v1 — rule-based is enough):

"summarize" node     → Haiku      ($0.00025/1k tokens)
"reason" node        → Sonnet     ($0.003/1k tokens)
"final answer" node  → GPT-4o     ($0.005/1k tokens)
"format" node        → Haiku
"extract" node       → Haiku

Key insight: most agent pipelines have 8 steps and only 2 actually need a frontier model. You don't need ML to capture 50% of the savings.

Integration — must be 3 lines max:

from yourproduct import optimize

graph = optimize(graph, budget="gpt4-for-reasoning-only")
# everything else unchanged

What Angie builds: Dashboard — before/after cost comparison, per-node breakdown, savings to date. This is the sales asset.

What Hosung builds: Middleware that intercepts LangGraph node execution and dispatches to right model.

Month 3 — 3 Design Partners

Go back to the companies from Month 1 with real bills. Offer:

Free for 30 days
You personally help set it up
They give feedback + a testimonial

Target outcome: 30%+ cost reduction on a real pipeline. Screenshot the before/after numbers. That's your entire sales deck.

Month 4 — Close 5 Paying Customers

Pricing options:

Flat: $299-499/mo
Savings share: 15% of documented savings (whichever is higher)

Savings-share is easier to close — zero risk for the buyer. If we don't save you money, you don't pay.

Sales asset from Month 3: "We reduced [Company X]'s LangGraph bill from $8,400/mo to $3,100/mo. Here's the screenshot."

Month 5-6 — Revenue + YC Story

Target: 5 customers × $400/mo = $2k MRR

Not life-changing but:

Proof the product works
Proof people pay
Real savings numbers to anchor a YC reapplication
Shows the market exists

The Real Risk

Not technical — you can build this.

The actual risk: Month 1 calls reveal that 18/20 companies have a $200/mo LLM bill. Market not ready.

If that happens: Pivot the ICP to larger companies (50+ engineers, shipped AI features to customers) or move to a different use case (internal tools teams at enterprises).

Do the 20 calls before writing a line of code.

Why Not Portkey / RouteLLM

Portkey: Gateway layer — optimizes per-call, not per-pipeline. Doesn't know you're on step 3 of 12. Doesn't cache intermediate agent states. We sit above it.
RouteLLM: Binary routing between 2 cloud models. No agent awareness. No framework integration. OSS, not a company attacking this space.
Gap we own: Nobody is optimizing the execution graph — the DAG of tasks — only individual LLM calls.

YC Reapplication Framing

Before: "We built an API proxy that tracks LLM costs" → Feature, not a company. Portkey already exists.

After: "We cut LLM costs for companies running agentic AI by 40-70% by routing each step in a multi-agent pipeline to the right-sized model — without changing existing code. $X saved across Y customers." → Specific. Measurable. Defensible. Plug-and-play.

Written 2026-03-17