BrainFlow - Your Brainstorming Partner on a canvas

BrainFlow turns an AI agent into a brainstorming partner that thinks on an infinite canvas with you. You type a topic. Instead of returning text, the agent generates a live mind map — nodes bloom in one at a time, edges animate as connections form, and every run produces a completely different visual structure. The UI isn’t a container for the agent’s output. The UI is the output.

Why spatial, not conversational. Ideas are graphs, not paragraphs. They branch, cluster, conflict, and link across categories. Chat interfaces flatten all of that into a scrolling column. BrainFlow gives the agent direct hands on a React Flow canvas: it calls add_node, add_edge, challenge_node, and prioritize_nodes — and each tool call renders as a styled node or edge the moment it arrives. The interaction loop is inherently two-way. While the agent is still generating, the user can right-click any node to expand it, challenge it, or ask for non-obvious connections. A mode selector swaps the agent mid-session — Brainstorm, Architect, Critic, Researcher — and the same canvas starts producing different kinds of thinking.

Generative UI, end to end. BrainFlow is a working reference for the modern open agent-UI stack:

AG-UI Protocol carries every TOOL_CALL_START / TOOL_CALL_ARGS / TOOL_CALL_END event from agent to browser. Each tool call is a UI generation event; the frontend paints a ghost node on START and finalizes it on END.
CopilotKit (useCopilotAction, useCopilotReadable, render props) registers the canvas’s tools as things the agent can call, and streams the live canvas state back so the agent always knows what’s on screen. Zero custom SSE parsing.
ag-ui-langgraph bridges a Python LangGraph StateGraph to the AG-UI wire format, so the agent brain is swappable without touching the frontend.
React Flow + dagre handle the canvas itself, with sequential tool calling (parallel_tool_calls=False) forcing the one-node-at-a-time streaming effect.
Why this matters for agentic interfaces. Most “AI mind map” products generate the whole map in one shot and hand it to you. BrainFlow generates it in front of you, and the agent is steerable mid-generation. Because the contract between agent and UI is just the AG-UI protocol, the same canvas could be driven tomorrow by a Claude-based strategist, a Gemini-based researcher, or a local model — without the frontend knowing or caring. That’s the real promise of generative UI: the interface stops being something you ship and starts being something the agent composes, one tool call at a time.

What I changed and why:

Lead with the experience, not a definition. The reader sees nodes blooming before they see tech.
Dropped “truly generative,” “unique spatial UI,” “redirect while thinking.” Replaced with concrete verbs (right-click, expand, challenge, swap).
Merged “Originality” and “Technical execution” into one closing paragraph that ties the tech choices back to the hackathon theme (“agentic interfaces”).
Cut repetition of “streaming” from 4 mentions to 2.
Kept every technical name-drop judges will look for: AG-UI Protocol, CopilotKit, useCopilotAction, useCopilotReadable, render, ag-ui-langgraph, LangGraph, StateGraph, React Flow, dagre, parallel_tool_calls=False, SSE, JSON-RPC is implied via CopilotKit.
Closing line lands the thesis: “the interface stops being something you ship and starts being something the agent composes” — that’s the one-sentence judge-takeaway.

Nothing was created Prior to Hackathon.
from ideation to coding, everything was done in 4 hours to uphold the spirit of a hackathon.
I have written about my work with these protocols in the past :
https://www.namanrajpal.com/blog