ConsultingDAG

Your autonomous co-founder agent. Give it an idea, and a team of Gemini agents plans, collaborates, and builds a founder-ready business blueprint with you in the loop.

Comment

Inspiration

Turning an idea into a real business means standing up a whole team — engineering, finance, marketing — and making a hundred judgment calls along the way. It's slow and expensive, and most AI tools just hand you a wall of text you can't steer.

I didn't want a chatbot that generates a business plan. I wanted an autonomous co-founder that builds one with me — a team of AI specialists that does real work, pauses for the decisions that are genuinely mine, and compiles everything into a founder-ready blueprint. That's the spirit of Track 2: a collaborative partner, not a black box.

What it does

You give ConsultingDAG a known asset — a GitHub repo or a startup idea. An orchestrator agent reads it and plans a directed acyclic graph (DAG) of specialist agents tailored to that asset: a CTO for architecture, a CFO for pricing, a CMO for go-to-market, and more. Every node on the canvas is its own agent, with its own role, instructions, and tools, and they hand work down the graph.

Then you hit Collaborate & Run. The agents execute autonomously — until the plan reaches a decision that's really yours to make. The CFO stops and asks: freemium, or strictly paid? You answer; the choice propagates to every downstream agent (so no one re-asks it); the flow resumes. Beyond text, a node can generate an image — on approval it calls Gemini's image model to produce an ad poster on the spot. When the run finishes, every per-node deliverable — tables, a mermaid architecture diagram, a slide deck, the poster — compiles into a single business blueprint you can read and export. Individual artifacts, the flow JSON, and a canvas image are all exportable too.

How we built it

Stack: Next.js (App Router) · React Flow · Zustand · the Google Agent Development Kit (ADK) for TypeScript · Gemini · SQLite — deployed on Google Cloud Run.

  • Builder + Runner, not a monolith. The ADK runtime has two roles: a Builder agent plans the DAG (returns strict JSON, hardened into a valid, laid-out graph), and a Runner executes each node as its own LlmAgent over a shared session. The executive roles are generated per run to fit your asset — not a fixed template.
  • Google AI throughout. Every agent calls Gemini via the ADK, routed through an AI Studio key or Vertex AI (ADC) with a single env flip, all behind one resolveModelConfig helper. Image generation uses Gemini's dedicated image model.
  • Human-in-the-loop that steers the graph. The orchestrator plants exactly one human checkpoint; the answer folds into shared state so the whole team stays in sync.
  • Model Armor guardrails. Real ADK before/afterModelCallback + beforeToolCallback block prompt injection, redact secrets/PII, and veto unsafe tool calls — at the framework level.
  • Persistent Memory Bank. A SQLite-backed ADK BaseMemoryService gives the team durable, cross-session memory that survives restarts.
  • Deployed on Google Cloud. Built locally for linux/amd64, pushed to Artifact Registry, and served on Cloud Run (scale-to-zero, stateless), with a per-IP rate limiter, Vertex quota caps, and a budget kill-switch Cloud Function as cost/abuse controls.

Challenges we ran into

  • A page-freeze that only happened in real Chrome. The report view locked up in a GPU browser but ran fine headless. The culprit wasn't markdown or mermaid — it was a backdrop-blur overlay composited over infinitely-animating SVG edges, starving the compositor. Pausing edge animations whenever an overlay is open fixed it.
  • Vertex model availability by region. gemini-3.5-flash returned a clean 404 on regional us-central1 but 200 on the global endpoint — Gemini publisher models aren't "enabled," they're served in specific locations. Verifying the model with a raw REST call before deploy saved a runtime failure.
  • Containerizing a native dep behind a corporate proxy. better-sqlite3 needs the build's Node major to match the runtime's, and a TLS-inspecting proxy broke npm in the Docker build. Pinning node:22 + pnpm and trusting an extra root CA via a build-time secret (never in the runtime image) got a clean, portable build.
  • Keeping the team in sync. Preventing agents from re-asking a decided question meant propagating human answers into shared state that every downstream node reads.

Accomplishments that we're proud of

  • A genuinely multi-agent system where the team is generated per asset, not hardcoded — and where a single human answer visibly reshapes the downstream plan.
  • Real guardrails and real memory using the ADK's own callback and memory primitives, not bolted-on wrappers.
  • End-to-end on Google Cloud, with both the app (Cloud Run) and the model (Vertex AI) in the same project — plus real cost/abuse controls so a public URL is safe to share.
  • Demoable offline. No key falls back to a deterministic heuristic planner + preset artifacts, so the whole flow still runs.

What we learned

  • The ADK's Builder/Runner split and shared sessions are a clean way to model a human-in-the-loop multi-agent graph — the checkpoint and memory fall out naturally.
  • "Works headless" ≠ "works on a GPU": some bugs are compositor-level, not logic-level.
  • With Gemini on Vertex, region/endpoint is as important as the model id.
  • Good agent UX is about where you pause — one well-placed decision beats a dozen confirmations.

What's next for ConsultingDAG

  • Parallel execution via the ADK ParallelAgent for independent branches.
  • A durable, multi-user backend (persistent Memory Bank beyond a single instance).
  • Richer artifacts — real slide-deck export, and optionally a distinct Google model (e.g. Gemma for a mixed-model team, or Veo/Lyria for richer marketing assets).
  • Deeper repo analysis tools for the technical-due-diligence path.

Built With

Share this project:

Updates

Submission history