Plug it into Claude Code, Cursor, or any MCP-compatible agent — and from that moment, the agent is inside your project graph.

The agent uses your project as documentation, the mind-map graph grows organically as the agent develops the project, and you just track it, add features, write to the graph, and let the agent sync and keep working.

You watch it happen. In realtime. On the same graph view you were just editing.

What MCP actually means here

MCP (Model Context Protocol) is how agents talk to tools. We expose 24+ tools that map 1:1 to graph operations:

get_tree, get_node, get_full_context — read project structure
find_nodes — full-text search with tag filters
add_child, add_rogue_node, batch_create_nodes — create work
update_node, delete_node, complete_node, move_node, create_edge — mutate
list_tags, create_tag, delete_tag — manage taxonomy
get_priority_order — the ranked TODO (manual_priority + hard constraints + blocker pass)
suggest_unblocked_next — top N tasks that have no remaining blockers
get_timeline — Gantt-style projection: when each task starts and ends, with deadline conflicts
get_sprint_summary — committed effort days, overcommit ratio, stale-task count, top-5-by-effort
get_dependencies, audit_graph, repair_graph — graph hygiene
get_project, connection_status

Every call is a real mutation on your real project.

How a single prompt becomes a whole feature tree

Tell Claude Code: "Plan out the OAuth integration feature for me."

Here's what happens in the next few seconds:

Agent calls get_tree — sees where feature work lives in your project
Agent calls find_nodes — checks if OAuth work already exists (no duplicates)
Agent calls batch_create_nodes — drops a hierarchical tree: parent "OAuth Integration" with children "Provider setup", "Token exchange", "Refresh flow", "Error handling", each tagged appropriately
Agent calls update_node to set ranks via manual_priority, so the TODO list reflects the right order
Optionally agent calls get_sprint_summary to confirm capacity, or set_deadline to lock dates

On your screen? You see the nodes appear. Bursting in, one by one, connecting themselves, glowing with their tag colors. The TODO list updates with the new ranks. No refresh. No reload. You were just watching your empty graph a second ago and now there's a full feature tree on it.

The realtime part — how it actually works

Under the hood: Yjs CRDT + Supabase Realtime broadcast channels.

Every project has a dedicated channel: yjs-project-{projectId}. Both the frontend (your browser) and the MCP server (wherever your agent runs) subscribe to it.

When the agent creates a node, the MCP server:

Applies the change to a local Y.Doc
Saves the delta to the database via RPC
Broadcasts the update over the Realtime channel

Your browser receives the broadcast, applies the same Yjs update to its own Y.Doc, and React re-renders the graph. The whole round trip is sub-200ms.

This is bidirectional. The agent edits — you see it. You drag a node — the agent sees it. You're both operating on the same shared document at the same time. If you're writing notes on a node while the agent is restructuring a sibling, neither of you blocks the other. CRDTs handle the merge.

Authentication without pain

You don't type API keys into Claude Code. You go to your Develosaur project, hit "Connect Agent", and download a develosaur.json file. Drop it in your project root. That's it.

The MCP server walks up the directory tree to find it, exchanges the API key for a short-lived JWT (60 minutes, auto-refreshed), and scopes every single call to that project. The agent literally cannot touch any other project — the JWT claim won't let it.

Built-in slash commands

We ship four prompts the agent can invoke on itself:

/develosaur-init — connect to a project and read the current state
/develosaur-work — pick the highest-ranked leaf task. Starts with get_sprint_summary health check; if overcommit_ratio > 1.2, recommends deprioritizing first. Tags the chosen task IN-PROGRESS so it surfaces in the In Progress section.
/develosaur-sync — sync recent work back to the board. Find related nodes, add implementation notes to their content, mark complete the ones that are done, create follow-ups for what surfaced.
/develosaur-collaborate — weekly cleanup. Run get_sprint_summary first; flag overcommit and stale nodes; propose blockers, ranks, deadlines, score corrections, structural fixes. Re-verify with get_priority_order and get_sprint_summary at the end.

Meaning: you can say "start working" and the agent pulls task #1 from the ranked TODO list, tags it IN-PROGRESS, walks through it, marks it complete, and moves to #2. You watch your graph update itself while you drink coffee.

Seven action types in Chat — same model, in-app

The Cloud Chat panel (in-app) speaks the same language. It proposes seven action types:

add_blocker — express that one node can't be built until another is done
set_scores — set value/effort on leaf tasks (advisory, feeds the value/effort chart and Gantt schedule)
add_tag — attach an existing tag (positive-weight tags are what surface a node in TODO)
create_node — add a foundational node multiple others implicitly depend on
set_parent — relink a node under a more semantically appropriate parent
set_manual_priority — explicit rank, lower number = higher priority
set_deadline — set or clear an ISO date deadline

Every action queues for your review. You accept the ones that look right, reject the ones that don't.

Why this matters

DeveloSaur treats agents as collaborators. Same graph. Same realtime channel. Same engine deciding what's next. When the agent completes a task, the graph updates and the next task surfaces — for both of you.

The "less management" philosophy already removed humans from the management layer. MCP removes them from the execution bookkeeping layer too. The agent tags, scores, ranks, creates, completes. You write, review, ship.

You don't manage the tool. You don't manage the agent. You watch the project build itself, step in when it matters, and the graph keeps moving.

Connect an agent and watch it work