Growth Engine

One brand profile. 16 AI agents. Growth Engine turns Gemini into a marketing team that researches, strategizes, and generates SEO, ads, emails & launch plans—streamed live.

Comment

Inspiration

I'm a solo founder. I can build the product, but marketing? That's where I hit a wall every single time. Writing SEO copy, planning email sequences, figuring out a launch strategy, making creatives that don't look terrible — that's a full team's worth of work. Agencies want $5k/month. ChatGPT gives you a generic blog post outline and calls it a strategy.

I wanted something in between. Something that actually knows my brand and spits out a real, usable marketing toolkit — not a glorified brainstorm.

When the Gemini Live Agent Challenge dropped, multi-agent architecture clicked immediately. Marketing isn't one task. Research feeds into strategy. Strategy shapes creative. Each step depends on the last. That's a pipeline, and that's what coordinated agents are good at.

What it does

You give Growth Engine your brand info (or just a URL), and it builds out a full marketing toolkit using coordinated AI agents:

  1. Brand Blueprint — Paste your URL or fill in details manually. Gemini pulls out your product context, audience, tone, and positioning.
  2. Foundation Phase — A Research Agent digs into your market (competitors, trends, gaps), then a Strategy Agent uses that research to build out personas, channel recommendations, and key messages.
  3. Marketing Audit — Scores your brand's marketing readiness across 6 dimensions (Content & Messaging, Conversion Optimization, SEO Discoverability, Competitive Positioning, Brand & Trust, Growth & Strategy) on a 0–100 scale with a letter grade.
  4. On-Demand Agents — Generate specific assets whenever you need them:
    • Marketing Creatives — Social posts, ad copy, image assets
    • On-Page SEO Fixer — Audits your live pages and gives you exact before/after code fixes
    • Launch Manager — A 30-day execution plan with actual milestones, not vague advice
    • Email Strategist — Ready-to-send sequences (welcome drips, nurture flows, re-engagement)

Everything streams live via SSE. You watch the agents work in real-time, which honestly makes the whole experience way more satisfying than staring at a spinner.

How we built it

Architecture: Two-Phase Multi-Agent System

The key design decision was splitting work into a Foundation phase (runs once, does the heavy lifting) and On-Demand agents (run individually, reuse the foundation). This way agents aren't redundantly re-researching your brand every time.

The pipeline looks like:

Brand Blueprint → Research Agent → Director Briefing → Strategy Agent → Foundation Foundation → On-Demand Agents (Creatives, SEO, Launch, Email) | Audit Pipeline (Analysis Agent → Audit Agent)

Director Briefings are worth calling out specifically. Between agent handoffs, a lightweight Gemini call reads the previous agent's output and distills it into 3–5 sentences of focused direction for the next agent. This was probably the single most impactful design decision we made (more on that in Challenges).

Tech Stack:

  • Backend: Python / FastAPI with async SSE streaming
  • AI: Gemini 2.5 Flash via google-genai SDK with function calling (tool-use loop, max 10 iterations per agent)
  • Frontend: Next.js 16, React 19, Tailwind CSS v4
  • Storage: Firestore (workspaces, blueprints, foundations, agent outputs) + Google Cloud Storage (images, logos)
  • Brand Extraction: Playwright headless browser + Gemini multimodal to parse any URL into a structured brand profile
  • Auth: Firebase Auth with anonymous guest access + Google sign-in upgrade (preserves all data on account link)

Agent System: Each agent has an instruction template, a tool set, and a Pydantic output model. The runner executes a Gemini function-calling loop where the model invokes tools (web search, grounding, analysis) and iterates until it produces valid structured output. Some agents use multi-phase pipelines — the Audit does analysis then scoring, the Planner generates tasks then expands each with verified URLs.

Challenges we ran into

Agent coordination without context bloat. My first instinct was to pass the full raw output from one agent to the next. This made everything worse. The models got confused, outputs got generic, and token costs ballooned. The fix was the director briefing pattern — a concise 3–5 sentence handoff between agents. Turns out agents work much better with focused direction than with an information dump.

Structured output reliability. Gemini sometimes wraps JSON in markdown fences or drifts from the schema mid-response. I wrote an extract_json() utility that strips fences, validates against the expected schema, and retries on failure. Boring but necessary — without it the pipeline breaks constantly.

SSE streaming across multi-phase agents. The Foundation runs 2 sequential agents. The Audit has 2 phases. On-Demand agents run solo. Keeping the frontend in sync across all these patterns required a careful event protocol so the UI always knows which agent is running, what phase it's in, and when it's done.

Staleness propagation. When you refresh your Foundation, every downstream agent output is now stale. Designing how staleness flows through the system (and how the UI communicates it — badges, refresh prompts, visual dimming) took more iteration than expected.

Accomplishments that we're proud of

Director briefings actually work. A 3–5 sentence handoff between agents sounds almost too simple, but it improved output quality across every single agent. It's now how the entire multi-agent system stays coherent.

Real-time streaming feels great. Watching agents call tools, process intermediate results, and build up their output live gives you way more confidence in the final result than a loading bar ever could.

The audit scoring system is genuinely useful. A 0–100 score across 6 marketing dimensions with specific recommendations. It makes "how's my marketing?" an answerable question instead of a vibe check.

One-click brand extraction. Paste a URL → Playwright scrapes it → Gemini multimodal analyzes it → you get a complete brand profile. No forms, no manual setup.

Guest-to-user upgrade. Anonymous users get the full product. When they sign in with Google, their Firebase UID is preserved through the account link so nothing is lost. Zero friction.

What we learned

Less context beats more context. Counterintuitive, but agents produce better output with a focused 3–5 sentence brief than with a full data dump. Information overload hurts LLMs the same way it hurts people.

Agent boundaries matter. Defining exactly what each agent owns (and explicitly what it doesn't) prevents overlap and keeps outputs from going mushy.

Streaming builds trust. When users can see tool calls happening and intermediate results forming, they trust the final output far more than if it just appeared after a loading screen.

Staleness is a feature. Explicitly marking downstream outputs as stale when upstream data changes keeps users from acting on outdated info. It felt like an edge case at first but it's actually core UX.

What's next for Growth Engine

  • More on-demand agents — ad copy generation, content calendar planning, social media scheduling
  • Agent collaboration — letting agents reference each other's outputs (e.g., creatives pulling SEO keywords automatically)
  • Export & integrations — one-click export to Google Docs, Notion, direct publishing to WordPress and Mailchimp
  • Team workspaces — multi-user access so small teams can share a brand profile and split agent runs

Built With

  • fastapi
  • firebase-auth
  • firestore
  • gemini-2.5-flash
  • gemini-3-flash
  • gemini-3.1-flash-image-generation
  • gemini-3.1-pro
  • google-cloud
  • google-genai-sdk
  • next.js
  • playwright
  • pydantic
  • python
  • react
  • tailwind-css
  • typescript
Share this project:

Updates