Flare
A graph-first IDE for agentic coding: watch Claude, Codex and opencode agents edit your repo live on a dependency map, with review, undo and multi-agent coordination built in.
- Source repo
- AlgoNoRhythm/Flare
- Stars
- ★ 309
- Last updated
- 1mo ago
- License
- MIT
- Primary language
- TypeScript
- FA score
- 58/100 · Major gaps
At a glance
- How it runs
- Works with
- Universal · cross-platformCodex · Claude Code
- Cost
- Free, no paid service needed
- Setup effort
- Medium · a few setup steps
- You'll need
- Typical use
- A solo developer running several agents at once (two Claude Code sessions plus a Codex) who needs to know who wrote which file and avoid silent collisions
- Not a fit if
- Developers who only want a chat-style AI coding assistant with no graph or visual collaboration surface
- Apple silicon users who need a fully validated build (arm64 packages are still beta and never launched on that hardware)
- Source review
- 58/100 · Major gaps
What does this agent do, and when should you use it?
Flare is an open-source (MIT) desktop IDE that can also be served to a browser from the machine your agents run on. Its main surface is a live dependency graph of your codebase — every file a node, imports as edges — with a full terminal underneath where you run claude, codex or opencode. As agents edit files the graph patches in real time, and every change burst is snapshotted into a local shadow history (a separate GIT_DIR) you can diff against and revert. A localhost MCP server (default port 7345) exposes tools such as graph_overview, impact_of, tasks_list, record_intent and chat_post, and names each agent session (Claude 1, Claude 2, Codex 1) so multiple agents can be told apart. Flare adds a kanban task board, design-decision proposals, a question queue, a Channel room for agent coordination, and a review cockpit that tiers changes by blast radius and verification status. It targets human–agent collaboration on one shared map, built for several agents at a time.
Flare's pure engine (shared/) scans a project with a comment/string-safe import parser, module resolver and incremental graph builder; a chokidar watcher re-parses changed files and patches the graph (evt:graphPatch). electron/core.ts is the windowless backend; the desktop main process and the browser server (server/, one websocket per session) are adapters over the same core, enforced by tests/singleSource.test.ts. It watches the process tree under its terminals to attribute file writes to claude/codex/opencode/aider sessions, logs every shell command with a class (read/writes/verify/network/destructive), and raises alerts plus snapshots on destructive commands (rm -rf, git reset --hard, push --force, npm publish). The MCP server exposes a per-project …/mcp/<slug> endpoint with tools including graph_overview, file_info, dependents, impact_of, verification_status, record_intent, tasks_list/task_get/task_update/task_create, decision_record, question_ask, working_agreement, chat_post/chat_read/agents_list and session_summary. The review cockpit groups changes into per-author bursts, states what actually checked them (quoting terminal output), tiers files read carefully/read/skim from blast radius, coverage and cycles, lists agent smells (deleted assertions, lowered coverage thresholds, test edited alongside code), and supports one-click undo per burst. Dropping an lcov.info into coverage/ or the project root ingests live coverage.
- A solo developer running several agents at once (two Claude Code sessions plus a Codex) who needs to know who wrote which file and avoid silent collisions
- An engineer whose agents run on a VM, dev container or cloud workstation, using
npm run serveand a browser with locally-echoed terminal keystrokes - A maintainer reviewing large agent changesets: walk files worst-risk first, revert one burst, or jump back to the last state whose checks passed
- A team that wants agents to announce files in the Channel, record architectural decisions as proposals awaiting approval, and park questions on the board instead of halting
- A tech lead assessing where a repo is fragile via the Hotspots (churn × complexity), Risk, Cycles and Reuse lenses recolouring the same graph
How do you install or deploy this agent?
Requires Node.js 20 or newer.
npm install
npm run build # bundle main process (esbuild) + renderer (vite)
npm start # launch the desktop appOr grab a prebuilt release from GitHub Releases: Windows Flare-<version>-Windows-x64.exe (NSIS installer); macOS arm64/x64 beta DMGs (ad-hoc signed and un-notarised — open once via right-click → Open, or run xattr -dr com.apple.quarantine /Applications/Flare.app); Linux AppImage, .deb and .tar.gz.
Browser / remote mode:
npm install
npm run serve # or `npm run serve -- /path/to/project`Register Flare as an MCP server for Claude Code:
claude mcp add --transport http flare http://127.0.0.1:7345/mcp/<slug>Development mode (renderer hot reload): npm run dev.
How do you use this agent?
- Launch Flare and pick a project folder from the start screen (
FLARE_PROJECT=<path>opens a project directly). - Run your agent in the terminal below, e.g.
claude,codexoropencode; Flare identifies and attributes its changes via the process tree. - (Recommended) Click Connect agent in the terminal bar, register the MCP endpoint, and start the agent with the provided opening message so it calls
working_agreementfirst. - Switch views (Canvas / Wheel / Districts) and lenses (Clusters, Activity, Hotspots, Risk, Tests, Coverage, Instability, Reuse, Unread, Cycles) from the toolbar or command palette (Ctrl+K).
- File work as task cards in the Control panel (right-click a graph selection → "New task with these files") and configure the ⚙︎ Routine wizard: check the board before stopping, record design decisions, park questions.
- Review bursts in the Review cockpit, check verification status and risk tiers, and diff or revert shadow-history snapshots from the timeline.
- Key shortcuts: Ctrl+K palette, Ctrl+B sidebar, Ctrl+0 fit graph,
?for a cheat sheet of every interaction in the current view.
What are this agent's strengths and limitations?
- Graph-first perspective: change attribution, blast radius and ten lenses on one map, no grep archaeology needed
- Deliberately built for multi-agent work: MCP session identities (Claude 1 / Claude 2 / Codex 1), a Channel for claims, and atomic board claiming prevent interleaved agent edits from being silently merged
- Review cockpit goes beyond per-file diffs: verification states quote real terminal output, session summaries are audited against observed writes, and each burst is one-click undoable
- Local shadow history (a hidden git repo with a separate GIT_DIR) never touches your real repo — 'git of local changes'
- One implementation, two transports: desktop and browser/remote serving from the same core, enforced by
tests/singleSource.test.ts
- macOS builds are beta, ad-hoc signed and un-notarised (Gatekeeper refuses first launch), and the arm64 package has never been launched on Apple silicon
- Requires Node.js 20+ and a native node-pty binary; cross-platform packaging must be built on the target platform
- Review-by-terminal depends on the backend running on the machine the agent runs on, forcing the server mode when that isn't your laptop
- Agent-side value (claiming tasks, posting to the Channel, recording intent) rests on agents following tool descriptions, not enforcement — Flare states it cannot lock files
- Windows production signing depends on SignPath setup review and certificate issuance; CI currently uses test-signing
How does this agent compare with similar options?
The README positions Flare as a companion to terminal coding agents (claude, codex, opencode) rather than a replacement: you still run these CLIs in Flare's terminal, and Flare maps their changes onto the dependency graph and adds the collaboration and review layer. No competing graphical IDE products are named.
Key facts side by side with the most closely related agents.
| Agent | Source review | Form / cost | Stars | Updated | Language | Full support on |
|---|---|---|---|---|---|---|
| Flare This agent | 58 · Major gaps | Desktop appFree | ★ 309 | 1mo ago | TypeScript | Codex · Claude Code |
| Superset | 52 · Major gaps | Desktop appFreemium | ★ 16k | today | TypeScript | Codex · Claude Code |
| Gortex Code Intelligence | 78 · Good | CLIFree | ★ 2k | today | Go | Codex · Claude Code · OpenAI API · Claude API |
| Graft Code Context Layer | 73 · Some gaps | CLIFree + model costs | ★ 11k | 1d ago | TypeScript | Codex · Claude Code · OpenAI API · Claude API |
How does FollowAgents rate this agent?
Why each dimension lost points
README explicitly states Flare watches the filesystem rather than intercepting writes; Channel locks are advisory and can be ignored, and agents are not blocked from writing files another agent claimed. This is a deliberate trade-off but weakens least-privilege enforcement, so least_privilege scores 1. Design decisions require human agree/decline and agents cannot self-approve; destructive commands (rm -rf, push --force) raise alerts and trigger snapshots, so user_confirmation scores 2. The MCP endpoint is localhost-only, per-pid registered, and port-configurable, giving some data-flow transparency (2). However, README does not explain how sensitive data (credentials, secrets, terminal output) is stored or redacted; snapshots and command logs persist locally with no encryption/retention guidance, so sensitive_data_handling scores 1. Only four runtime dependencies with version floors, but no lockfile evidence, audit, SBOM, or vulnerability scanning, so dependency_security scores 1. External effects (terminal execution, file writes, MCP tools) are classified and alerted, scoring 2. Rollback is strong: per-burst snapshots, revert file/burst, jump to last passing state, scoring 3. Source attribution distinguishes Claude 1/Claude 2/Codex 1 via MCP sessions and attributes changes to specific agents, scoring 2.
Tests cover verificationFor, lastGreen, AgentRegistry, process detection, and snapshot splitting with edge cases (failure stays red after later pass, stale detection), so self_consistency scores 2. Dependency availability: package.json lists dependencies but no lockfile evidence; native module @lydell/node-pty requires platform prebuilds, and the release workflow acknowledges cross-build issues, so dependency_availability scores 1. Failure messages distinguish not-run/failed/stale/running/unknown and quote output lines, scoring 2.
README clearly targets developers using claude/codex/opencode, with rich scenarios (multi-agent coordination, review, task board), scoring 2 for audience_and_scenarios. Capability boundaries are stated (cannot lock files, does not block writes, watch-only), scoring 2. Trigger precision: stop hook fires once per stop and never points at a card another agent started, scoring 2. Environment fit: Windows/macOS/Linux packaging and browser-served mode, but Intel Mac and signing complexity, scoring 2.
README is detailed with screenshots and demo, scoring 2 for information_architecture. Install notes are thin: only MCP registration commands and npm scripts, lacking full from-scratch install/build steps, scoring 1. Naming stability: agent numbers never reused, stable slugs, scoring 2. Examples and FAQ: many examples and shortcut docs but no standalone FAQ, scoring 2. Known limitations are explicitly stated (no locking, no write blocking, e2e needs local display), scoring 2. LICENSE is full MIT, scoring 3. Version 2.1.0 exists but no CHANGELOG, scoring 1 for versioning_changelog. Maintenance responsibility: unverified publisher, single author email, scoring 1.
Output usability: graph views, review cockpit, task board, and MCP tool outputs are practical, scoring 2. Marginal value: graph-based dependencies, multi-agent attribution, and rollback add value over a plain IDE, scoring 2. Cost-benefit: Electron desktop app, native modules, multi-platform signing, and a complex MCP gateway impose high deployment/maintenance cost, scoring 1.
claim_traceability: README makes many feature claims; some are backed by tests (verification, registry) but most UI/graph-algorithm claims lack corresponding evidence, scoring 1. cross_source_corroboration: README, package.json, tests, and release workflow partially corroborate each other, but core graph and review logic source is not visible, scoring 1. fact_inference_separation: README distinguishes what Flare observed from what agents self-reported (session_summary audit), scoring 2.
- Channel locks are advisory only; agents can ignore them and write files another agent claimed. Do not treat them as enforced mutual exclusion.
- README does not describe sensitive-data handling, encryption, or retention for terminal output, command logs, and snapshots; assess local data exposure yourself.
- No lockfile or dependency-audit evidence; native module @lydell/node-pty requires platform prebuilds, so cross-platform deployment may fail.
- Publisher identity is unverified and maintenance/update path is unclear; verify provenance before adoption.
Recent releases
Latest entries from the project's GitHub Releases. Notes are quoted from upstream as written, not rewritten or tested by FollowAgents.
FAQ
Does Flare itself cost money or need an API key?
claude/codex/opencode sessions you run inside it.Do my agents have to connect via MCP?
Can multiple agents corrupt the same file?
Does it work on remote machines?
npm run serve on the machine the agent runs on and open the printed URL in a browser (token kept in ~/.flare/web-token). It detects Codespaces, Gitpod, jupyter-server-proxy and similar environments, works behind SSH tunnels and path-prefixed proxies, and --host 0.0.0.0 opens it to your network.