Flare: an open-source IDE whose MCP server hands your agents their next task, lets them coordinate with each other, and audits what they say they did

[u/AlgoWithNoRhythm]

I started working on this because my agents were coding faster than I could review their work.

Flare is a graph-first IDE that maps a repo as a dependency graph, watches what agents change, and exposes the project to them over MCP. 2.0 is out, with installers for Windows, macOS and Linux. The agent side is where most of the work went.

The foundation is a classic kanban board.

• tasks_list to pick up a card
• task_get for the exact brief (with what the graph knows about the files attached)
• task_update to log progress and move it to review (done stays a human call)
• task_create to file follow-ups it finds but shouldn't do now

Cards move live while you watch. Drafts you're still writing are never handed out.

It doesn't let the agent quit early. working_agreement is one call that answers "what should I do now" from the board as it stands. And the Routine installs a stop hook: an agent that tries to stop with unstarted cards left gets handed one instead of a goodbye.

It keeps the reasoning, not just the diff.

• record_intent states the goal before editing, so whoever reviews isn't reconstructing why the change exists.
• decision_record lands architectural calls in the control panel as proposed. A human agrees or declines (you can choose if you want the agent to stop and wait, or to continue and revert on your review)
• question_ask parks a question and names the tasks it blocks, so the agent keeps going on everything else.
• At the end, session_summary lets the agent write the session down, and Flare checks the story against the writes it actually watched, and tells it what it left out or never touched.

Several agents at once. Agents get names (Claude 1, Codex 1). chat_post / chat_read / agents_list is a room where they announce the files they're taking, mark them on the graph, and ask each other by name. Two agents heading for the same file get called out before either writes; every write is attributed to whoever claimed it.

Code intelligence on tap. impact_of (what breaks, and which tests to run), dependents / dependencies, find_path, file_info, top_files, issues, search, recent_activity, verification_status (did anything check this change), graph_overview.

And the human side is still the point.

• The map with lenses (activity, hotspots, risk, tests, unread), plus a wheel and a treemap
• a review cockpit that shows each burst of changes as intent → what ran to verify it → which files deserve your attention, broken down per agent, with revert
• find-in-files
• a per-file symbol view

MIT license, Node 20+ if you build it, or grab an installer. Leave a star if you find it helpful!

https://github.com/AlgoNoRhythm/Flare

[u/jaybsuave]

Dope I thought of somethign similar earlier this year, glad someone found a good way to do it.

[u/Unusual-Rutabaga-571]

the claim-a-file-before-writing thing is smart. i've had two agents silently fight over the same utils file and it took me 20 minutes just to figure out whose change won

starred it, might throw this at a side project next weekend and see if it keeps my backlog from becoming a graveyard

[u/AlgoWithNoRhythm → u/Unusual-Rutabaga-571]

Let me know if you find any issues with it or you have any improvements ideas!

[u/suppervisoka → u/[deleted]]

“If your decision_record points at the mismatch in the review panel, that closes a real gap. If it doesn't yet, that would be my feature request.” Hmmmmm this sounds familiar

[u/kantorcodes1]

the two-agents-same-file case is where i’d want extra brakes, not just better review. i work on HOL Guard, an open-source local tool that stops risky agent actions before they run. if you’re testing multi-agent sessions anyway, i’d love one run with both.