Type a company name. Get funding history, competitors, strengths, risks, and a verdict — written by three AI agents that hand real work off to each other, not one model faking a team. Here's how StartupScope works, and what building it taught me about production LLM systems.
Quick facts: 3 sequential agents · Groq LLaMA 3.3 70B · live web search with fallback · MIT licensed · reports typically land in well under 90 seconds (my last Stripe run finished in 46s)
The problem
Every time I wanted to size up a company — for a job application, a comparison, or just curiosity — I'd end up with 15 tabs open: Crunchbase, TechCrunch, the company's own site, a couple of "top competitors" listicles, LinkedIn. Ten minutes of tab-switching to answer one question: what does this company actually do, and should I care?
So I built StartupScope. Type a company name, and three AI agents research, analyze, and write a structured intelligence report — funding history, business model, competitors, strengths, risks, a verdict. Compare two companies side by side if you want. Most runs finish in under 90 seconds.
Live demo: startupscope-ai.streamlit.app
Code: github.com/ayush-s-tomar/startupscope
Here's the single-company flow, start to finish:
And here's Compare Mode — two full intelligence reports generated and rendered side by side in one run:
Why three agents instead of one prompt
My first version was a single LLM call with a big prompt: "research this company and write a report." It worked, technically. It also hallucinated funding numbers with total confidence, blurred "what they do" into "why they're good," and produced the same generic paragraph shape no matter how much real data it had found.
The fix wasn't a better prompt — it was splitting the job into three roles that pass a shared, structured context object down the line:
User Input (Company Name)
│
▼
[Agent 1 · Researcher]
Searches the web (Serper → DuckDuckGo fallback),
ranks sources by credibility, writes findings into
shared agent_context
│
▼
[Agent 2 · Analyst]
Reads agent_context, extracts strengths, risks,
market opportunity, and a verdict
│
▼
[Agent 3 · Writer]
Reads the fully-populated agent_context,
formats everything into a clean markdown report
│
▼
Markdown Report (.md) + Structured JSON (.json)
Splitting finding information (Researcher), judging it (Analyst), and presenting it (Writer) into separate CrewAI agents made a bigger quality difference than any prompt tweak I tried. Each agent has one job and a narrow, well-defined output — which made the pipeline far easier to debug too, since I could inspect agent_context at each handoff instead of reverse-engineering one giant completion.
Three agents fixed the structure. They didn't, on their own, fix the lying.
The hard part: making it not lie
The real problem with a tool like this isn't "can an LLM summarize a company" — it's "can I stop it from confidently inventing a Series B round that never happened."
A few things mattered more than I expected:
Source credibility scoring. Search results are ranked by domain trust before the Researcher agent even reads them — Crunchbase, TechCrunch, and Reuters outrank random forum posts and SEO-farm "top 10 competitors" listicles. Garbage in, garbage out is very real when your input is live web search.
Explicit permission to say "I don't know." The agents are instructed to output "Not specified" rather than guess when a field — founding year, exact funding total, HQ — isn't in the source data. It's a small instruction with an outsized effect: it's what separates a tool you can trust from one that just sounds confident either way. Some companies genuinely don't disclose this stuff publicly, and the report should say that plainly instead of papering over the gap.
Search fallback. Serper is the primary search provider, but free-tier quotas run out and third-party APIs go down. DuckDuckGo is the fallback, so a quota hit doesn't mean a dead app.
Retries with backoff. Groq's free tier and Serper's free tier both rate-limit. Instead of the whole run crashing on a transient 429, failed steps retry with exponential backoff. Unglamorous, but it's what separates a demo that works once from a tool people can rely on.
None of that shows up on screen, though. The next problem was making the 60-plus seconds it takes actually feel trustworthy while it's happening.
Killing the silent spinner
Small thing, but it mattered a lot for how the tool felt to use: early versions had one spinner sitting there for 60–90 seconds with zero feedback. Users — including me — kept refreshing, assuming it had crashed.
Now every agent streams its status live:
🔍 Researcher is searching the web...
📊 Analyst is extracting insights...
✍️ Writer is composing the report...
Watching the three-stage pipeline actually work in real time, instead of staring at a spinner, changed how the tool felt — from "is this broken?" to "oh, it's doing three separate jobs." Same underlying latency, completely different perceived experience. The live step counter ("Step 2/4 · 34s elapsed") does double duty as a built-in performance readout. Nice side effect of building for UX: I get to watch my own regressions happen in real time too.
That's the experience layer. Underneath it, here's what's actually running the pipeline:
Tech stack
| Layer | Tech |
|---|---|
| Agent framework | CrewAI |
| LLM | Groq API (LLaMA 3.3 70B) |
| Web search | Serper Dev API + DuckDuckGo (fallback) |
| Frontend | Streamlit |
| Deployment | Streamlit Community Cloud |
| CI | GitHub Actions |
That's the core loop. A few things around the edges make it more than a one-shot demo:
What else it does
- Try an example — one-click company buttons (OpenAI, Anthropic, Stripe, Razorpay, Notion) pre-fill the input so you can see a full report before typing anything
- Compare Mode — research two companies in one run, view tabbed or side by side
- Report history — every past report is saved and browsable from a sidebar
-
Dual export — every run saves both a
.mdand a structured.json(typed schema: funding, competitors, strengths, risks, verdict), so the output is usable programmatically, not just readable - CLI batch mode — point it at a CSV of company names and it researches all of them sequentially, with a built-in delay to respect rate limits
-
CI on every push — GitHub Actions lints with
ruffand byte-compiles every module across Python 3.10–3.12 before anything reachesmain
# single company
python main.py --company Razorpay
# batch mode from CSV
python main.py --batch companies.csv
None of that means it's finished, though.
What I'd still change
Being honest about the rough edges:
- Report quality is only as fresh as Serper/DuckDuckGo results — a funding round announced an hour ago might not surface yet.
- Free-tier rate limits mean heavy back-to-back usage triggers the retry logic and slows things down.
None of this is secret; it's in the README's "Known Limitations" section on purpose. A report that's honest about its own gaps is more useful than one that pretends they don't exist.
Try it
Fifteen tabs down to one input box. That was the whole goal — go see if it holds up on a company you actually care about:
- Live app: startupscope-ai.streamlit.app
- Source: github.com/ayush-s-tomar/startupscope — MIT licensed, clone it and run it locally with your own free Groq + Serper keys
If you build multi-agent systems too, I'd genuinely like to hear how you handle agent-to-agent context passing. CrewAI's shared context object worked for me here, but I'm curious what else is out there for keeping a 3+ agent pipeline debuggable instead of a black box — drop your approach in the comments, I'm collecting ideas for the next iteration.
Built by Ayush Singh Tomar
Top comments (0)