VentureOS — The Story Behind the Build
Inspiration
The idea came from a frustration I've lived personally.
I'm a graduate student in Data Analytics at Washington University in St. Louis, working as a Research Assistant at the School of Medicine. Like a lot of people in technical programs, I've had startup ideas — some decent, some not — but every single time, the same thing happened: I'd spend days just researching. Market sizing. Competitor mapping. Feature prioritization. Writing cold emails to investors I wasn't even sure were the right fit. By the time I had a rough picture of the landscape, the energy that made the idea exciting in the first place had faded.
The question that started this project was simple: what if you could compress that entire research phase into two minutes?
Not a summary. Not a chatbot answer. A real, structured, investor-ready foundation — streamed live to your browser as eight specialized agents work in parallel, each an expert in its own domain.
That's VentureOS.
What It Does
You describe your startup idea in one sentence. Eight AI agents run in sequence and deliver twelve outputs:
- Market research with TAM, growth rate, and trend analysis
- Competitor analysis with real company logos and whitespace mapping
- Product strategy with MoSCoW-prioritized features, tech stack, and build timeline
- Pitch deck outline plus three personalized cold investor emails
- A fundability scorecard rated across five VC dimensions
- A live, interactive website prototype rendered in your browser
- A 3-year financial model with adjustable assumptions and CSV export
- Strategic pivot suggestions based on scorecard weaknesses
- Matched VC investors with real emails — one click opens your mail app
- An in-browser pitch deck with keyboard navigation and present mode
- A shareable report link
- A co-founder chat that knows your full analysis context
Every result streams live as each agent completes. The progress bar fills. The thinking log scrolls. You watch the research happen in real time.
How I Built It
The Multi-Agent Architecture
The core of VentureOS is an orchestration layer that runs five analysis agents sequentially, streaming results back to the browser via Server-Sent Events (SSE):
$$\text{Idea} \xrightarrow{\text{orchestrator}} A_1 \to A_2 \to A_3 \to A_4 \to A_5 \xrightarrow{\text{SSE}} \text{Browser}$$
Each agent $A_i$ receives the raw idea plus the structured outputs of all previous agents as context. This means the pitch agent knows the market size and competitor landscape before it writes a single slide. The scorecard agent has seen everything. Each output builds on the last.
The orchestrator yields SSE events:
def run_ventureOS_stream(idea: str):
yield status("Running Market Research agent...")
market = run_market_agent(idea, llm)
yield event("market_research", market)
yield status("Running Competitor Analysis agent...")
competitors = run_competitor_agent(idea, market, llm)
yield event("competitor_analysis", competitors)
# ... and so on
The frontend reads this stream with the ReadableStream API and renders each result card as it arrives — no page reload, no waiting for all agents to finish.
Structured JSON Outputs
Every agent is prompted to return only valid JSON — no explanation, no markdown, no preamble. Each has its own schema:
The scorecard agent, for example, scores the idea across five VC dimensions:
$$S_{total} = \sum_{i=1}^{5} s_i, \quad s_i \in [0, 20], \quad S_{total} \in [0, 100]$$
Where the five dimensions are: Market Size, Team Fit, Differentiation, Business Model, and Market Timing. The color of the score circle is computed dynamically:
$$\text{color} = \begin{cases} \text{green} & \text{if } S_{total} \geq 75 \ \text{amber} & \text{if } 55 \leq S_{total} < 75 \ \text{red} & \text{if } S_{total} < 55 \end{cases}$$
The Prototype Agent — Solving the CSS Isolation Problem
The prototype agent was the hardest to get right. The goal was to generate a complete, production-quality website and render it inside an iframe — but early versions had a critical bug: the parent page's CSS was leaking into the iframe, breaking the generated site's layout.
The fix was a two-part approach. First, I inject a hard CSS reset at the top of every generated HTML document:
*, *::before, *::after {
box-sizing: border-box !important;
margin: 0 !important;
padding: 0 !important;
}
Second — and more importantly — I changed the prompt strategy entirely. Instead of asking the LLM to invent a design system, I gave it the exact same CSS design system that VentureOS itself uses — Geist font, Instrument Serif, the same CSS custom properties, the same card classes, the same spacing scale. The LLM just writes HTML content using pre-defined classes. The design quality is guaranteed because the CSS is pre-written by a human, not hallucinated.
Financial Projections
The 3-year financial model computes month-by-month projections in the browser:
$$R_m = U_m \cdot \text{ARPU}$$
$$U_m = U_0 \cdot (1 + g)^m$$
$$P_m = R_m - C_{fixed}$$
$$\text{Cumulative P&L}m = \sum{k=1}^{m} P_k$$
Where $U_0$ is starting users, $g$ is monthly growth rate, ARPU is average revenue per user, and $C_{fixed}$ is the sum of monthly COGS and OpEx. Break-even is found at the first month $m^$ where $P_{m^} \geq 0$.
All five inputs are adjustable in real time — change growth rate, click Recalculate, the entire 36-month table and four summary stats update instantly.
The Pitch Deck — From Browser Bug to Flask Route
The in-browser pitch deck is generated by a /slides Flask route (to avoid CORS — you can't call the Anthropic API directly from a browser). Claude generates 10 slides as a structured JSON array, which the frontend renders as styled 16:9 cards with gradient backgrounds, stat boxes, bullet points, and a thumbnail strip.
The PPTX download was a journey. My first approach used PptxGenJS from a CDN — it worked locally but failed silently on Render because the library's global variable name changed between CDN versions, and percentage-based coordinates (x: '8%') are invalid in PptxGenJS (it uses inches). I rewrote it server-side using python-pptx, which is deterministic, has no CDN dependency, and produces a proper .pptx file that opens correctly in PowerPoint and Keynote.
The Stack
| Layer | Choice | Why |
|---|---|---|
| LLM | Groq + LLaMA 3.3-70b | Sub-second token generation — critical for live streaming |
| Agent Framework | LangChain | ChatPromptTemplate + structured message types |
| Backend | Flask | Lightweight, stream_with_context for SSE |
| Frontend | Vanilla HTML/CSS/JS | Zero build step, single file, deployable anywhere |
| PPTX | python-pptx | Server-side, no CDN dependency, works on all browsers |
| Logos | Clearbit API | Free, reliable, one line per competitor |
| Deployment | Render | Git-push deploys, environment variable encryption |
Challenges
1. Making streaming feel alive
SSE works, but early versions just showed a spinning loader until the final result appeared. The breakthrough was the agent thinking log — a scrolling terminal-style panel that shows what each agent actually found as it runs:
⟳ Market Research agent started
→ Market: $4.2B TAM, 28% growth rate
✓ Market Research complete ✓ [8.2s]
⟳ Competitor Analysis agent started
This made the AI feel transparent and trustworthy instead of like a black box.
2. JSON parsing reliability
LLMs occasionally return JSON wrapped in markdown code fences, or with trailing commas, or with a preamble sentence before the JSON starts. Every agent's output goes through a defensive parsing pipeline:
text = re.sub(r"```(?:json)?", "", text).replace("```", "").strip()
start = text.find("{")
end = text.rfind("}") + 1
data = json.loads(text[start:end])
This strips fences, finds the outermost {...} bounds, and parses only that slice. It handles about 95% of malformed outputs gracefully.
3. Groq model deprecations
During development, two model versions were deprecated mid-session. llama3-70b-8192 stopped working, then gemini-1.5-pro hit quota limits. Every time an agent failed silently, it took debugging to find which call was broken. The lesson: always wrap every LLM call in a try/except that logs the raw response, not just the exception.
4. CSS isolation in the prototype iframe
Described above — the breakthrough was pre-writing the design system in the agent rather than asking the LLM to invent one. The quality went from "student project" to "Dribbble shot" the moment I stopped prompting for style and started providing it.
5. Deploying to Python 3.14
Render defaulted to Python 3.14, which changed how langchain.prompts is resolved. from langchain.prompts import ChatPromptTemplate throws ModuleNotFoundError on 3.14 because the package moved the import path to langchain_core. Every agent file needed updating:
# Before
from langchain.prompts import ChatPromptTemplate
# After
from langchain_core.prompts import ChatPromptTemplate
What I Learned
Multi-agent systems are only as good as their context handoff. The biggest quality improvement came not from better individual agent prompts, but from passing richer context between agents. When the pitch agent knows the exact TAM figure and the top competitor's weakness, it writes a sharper email than when it only knows the raw idea.
Streaming UX is a product decision, not a technical one. The same data presented as a loading spinner versus a live thinking log creates completely different user emotions. The engineering effort is the same — the experience is not.
The LLM is the junior developer, the prompt is the senior one. Early prototype quality was poor because I was prompting vaguely — "build a nice website." Quality jumped when I treated the prompt like a precise engineering spec with a pre-written design system, mandatory sections, exact CSS class names, and a quality bar ("looks like a $50/month SaaS").
Never depend on a CDN for core functionality in production. The PptxGenJS CDN failure taught me that anything critical — file generation, PDF export, slide creation — should happen server-side where you control the environment. Browser-side libraries are fine for UI but not for deliverables.
Built With
Python · Flask · LangChain · Groq API · LLaMA 3.3-70b · Server-Sent Events · python-pptx · Clearbit API · Web Speech API · Render · GitHub
Built by Yogvid Wankhede — M.S. Data Analytics & Statistics, Washington University in St. Louis
Log in or sign up for Devpost to join the conversation.