CoFound

What inspired us

Every founder knows the feeling: you're the PM, the researcher, the marketer, and somehow also customer support — all before lunch.

We kept opening ChatGPT, getting decent answers, and then losing them. No memory of yesterday's market research. No connection between "who's our audience" and "what should we build next." Just another tab.

We wanted something that felt less like a chatbot and more like an operating system — one place where your startup actually lives, grows, and tells you what to do next.

That's CoFound.

What we built

CoFound takes a raw idea and models it as a living knowledge graph — 11 nodes from core idea through audience, market, competitors, revenue, product, tech, build, launch, observe, and growth.

A central orchestrator coordinates specialist agents that research each node, stream progress in real time, and surface one clear priority: today's highest-ROI move.

You can talk to it (voice via Deepgram) or type. Ask it to research competitor gaps and it spawns parallel agents, drops new nodes on the canvas, and wires them up. Pivot your idea and a diff classifier only resets what's actually affected — not the whole graph.

When the graph is ready, you export a scaffold zip (README, tech stack, UI spec, .cursorrules, handoff doc) and hand it straight to your editor.

Integrations hook into the loop: GitHub for build signals, PostHog for funnel drops, Reddit and web scraping for market evidence.

How we built it

Frontend: Vite, React, TypeScript, React Flow for the canvas, Zustand for state, GSAP for unlock animations.

Backend: FastAPI, Python 3.11. Gemini 2.5 Pro for orchestration and synthesis, Gemini Flash for the high-volume research loops.

Database: MongoDB Atlas stores the graph, task queue, decision journal, build/observe events, and a vector knowledge base. We wired the official MongoDB MCP server at runtime so agents read and write graph state through MCP tools — not just a static DB connection.

Agent stack: Google ADK planner decomposes workspace state into research tasks. Researchers run a Karpathy-style self-critique loop: gather evidence → synthesize → score → accept or requery. Results stream to the frontend over SSE.

Research tools: Firecrawl, Reddit (PRAW), Scrapling for stealth web fetching when pages block normal scrapers.

The orchestrator uses tool-calling — spawn research, pivot, export, open panels, hand off priorities — so conversation actually drives the product, not just describes it.

We split parallel work across three tracks (MongoDB/MCP, agents, frontend) with frozen API contracts so nobody blocked everyone else. Painful at first, saved us later.

What we learned

Graph state beats chat history. Startups aren't linear conversations. They're a web of decisions with dependencies. Modeling unlock thresholds (you can't seriously plan launch before audience is solid) made the product feel intentional instead of random.

Agents need a scoreboard. Letting researchers self-critique with a numeric threshold (we accept at 80+) cut down shallow answers way more than we expected. Dead ends get logged too — knowing what didn't work matters.

Persistence is the product. The hack wasn't making Gemini sound smart. It was making Monday's research show up on Tuesday's canvas, with a decision journal explaining why confidence moved.

Voice changes the vibe. Once the orchestrator orb worked, the product stopped feeling like a dashboard and started feeling like a co-founder you could actually talk to.

Demos lie. Our first version had fake project lists and hardcoded content. Stripping that out hurt visually but users immediately trusted it more. Real > flashy.

Challenges we faced

MongoDB MCP at runtime. Getting mongodb-mcp-server running inside the agent loop — with Node.js as a subprocess, connection pooling, and fallback when MCP hiccups — took more iterations than the entire voice pipeline.

Surgical pivot. Early pivots wiped the whole graph. Users hated it. Building a diff classifier that maps natural-language changes to specific nodes (and only re-researching those) was one of the harder ML problems in the project.

Keeping the canvas honest. Dynamic custom research nodes, animated edges, agent status dots, confidence rings — lots of UI state to sync with a graph that's mutating in the background over SSE. React Flow + live agent updates fought us more than once.

Integration depth vs. hackathon time. GitHub and PostHog connect flows exist, but real OAuth, Gmail, Slack, and true multi-project switching are still ahead. We scoped hard: one real loop (research → observe → priority → action) instead of ten half-built integrations.

Team velocity without chaos. Three people, three tracks, one demo deadline. Contract freezes and merge checklists felt bureaucratic until the alternative became three broken builds at 2am.

The math behind "today's priority" (sort of)

We don't pretend there's a perfect formula for startup ROI. But we do rank actions with a growth agent that weighs graph confidence, open gaps, and integration signals.

Roughly, node readiness looks like:

[ \text{readiness}(n) = \text{confidence}(n) \times \mathbb{1}[\text{unlocked}(n)] ]

Export unlocks when three critical nodes cross a threshold:

[ \text{confidence}(\text{revenue}) \geq 0.7 \;\land\; \text{confidence}(\text{product}) \geq 0.7 \;\land\; \text{confidence}(\text{tech}) \geq 0.7 ]

The real intelligence is in the agent reasoning and evidence — the math just keeps the UI honest about when you're actually ready to ship docs, not vibes.

Where it's going

OAuth for integrations. Real multi-project switching. Deeper observe → growth loops once more founders connect GitHub and PostHog. Persona lens once audience research is consistently solid.

probably going to add more features and continue working on it even after hackathon ends.