Who Flare is for#
Developers running Claude Code or Codex on real codebases
Flare provides the agent graph context (blast radius, coverage, import cycles) via MCP, reducing the context the agent needs to rediscover. You see which files changed, which are load-bearing, and whether tests ran, before deciding whether to keep the changes.
Skip if:
You use a cloud-based agent service that executes remotely. Flare's terminal watcher tracks only local processes, so remote agent sessions are invisible to it.
Teams coordinating multiple AI agents on a shared codebase
The kanban task board prevents agents from claiming the same card; the design-decisions log requires human approval for architectural calls before the code ships. All agents and the panel share one board, and concurrent writes are rebased rather than dropped.
Skip if:
Your agents work on entirely separate repositories. Flare's cross-agent features are valuable specifically when multiple agents share the same filesystem and task queue.
Solo developers who review agent output carefully
The review cockpit tiers changed files by blast radius, coverage, and complexity so you know which ones to read first. One-click revert on any burst means you never lose the ability to undo an agent's work, and the Unread lens shows which files changed but no human has opened since the last session.
Skip if:
You are comfortable reviewing raw diffs in a terminal workflow and do not need visual risk triage or one-click revert. Flare's value is in reducing the cost of careful review, not enabling review that was previously impossible.
Developers building MCP-native agent workflows
Flare exposes a localhost MCP server with tools covering graph queries, task management, design decisions, and working agreements. An agent can call impact_of to learn what breaks before editing a file, record_intent before editing to explain why, and working_agreement to get the current board state and house rules.
Skip if:
Your agent does not support MCP tool calls. The graph visualization and shadow history still work, but the deep integration (task claiming, decision logging, intent recording) requires MCP.
The problem it solves#
When an AI coding agent edits a large codebase, you face a flat list of diffs with no context about which files are load-bearing, which ones have test coverage, or whether any verification ran after the edits. Reviewing 30 files equally is slow; missing the one file that nine others import is risky.
Coordination is the second challenge. If you want multiple agents working through a task queue without stopping repeatedly to ask questions, you need a shared place to leave answers they can pick up, a mechanism for recording architectural decisions before the code that assumes them ships, and a way to prevent two agents from claiming the same work item at once. Standard terminal workflows provide none of that.
How it solves it#
Live codebase dependency graph
Maps every file as a node and every import as an edge across three view modes: Canvas (files ordered left-to-right by dependency depth), Wheel (all files on one ring with chord edges crossing the center), and Districts (treemap where area is lines of code). Ten switchable lenses recolor the layout by Activity, Hotspots, Risk, Tests, Coverage, Instability, Reuse, Cycles, and more.
Agent task board with MCP integration
A kanban board where cards are written to be handed to agents. 'Copy for agent' emits the card brief plus graph context about the named files, including blast radius, coverage percentage, and cycle membership. Agents claim cards over MCP using task_get and task_update; a card is only offered while it sits in the first lane, preventing two agents from taking the same work item.
Review cockpit with risk triage
Groups file changes into bursts by author and tiers every changed file as read carefully, read, or skim based on blast radius, coverage, complexity, and cycles. Flags agent-specific patterns: deleted assertions, added .skip/.only, lowered coverage thresholds, and complexity spikes. One-click revert on any burst, or jump back to the last snapshot whose checks passed.
Shadow history for agent edits
Auto-commits every burst of file changes to a hidden git repository with a separate GIT_DIR, leaving your real repo untouched. The timeline panel lists every snapshot; you can diff any file against any past state or restore the whole working tree. Destructive commands like rm -rf and git reset --hard trigger an automatic snapshot and raise an alert.
MCP server for agent graph queries
A localhost-only endpoint agents call to query the live graph without rediscovering it. Tools include graph_overview, file_info, dependents, impact_of (what breaks and which tests to run before changing a file), verification_status, record_intent, and the full task-board and decision-log API. Works with any MCP-compatible client including Claude Code.
Cross-agent coordination on one board
Multiple agents can work the same task board concurrently. A card is only offered if it sits in the first lane; moving it to in-progress claims it. Writes made against a board that changed since the agent last read it are rebased rather than dropped. Design-decision proposals require human approval before the code that assumes them ships.
Strengths and trade-offs#
Strengths
- Blast radius without grepHovering any file in the graph highlights every file that imports it transitively, in amber. Shift-clicking two nodes traces the dependency path between them. The impact_of MCP tool returns the same information to the agent so it knows what to test before editing a file. No grep or manual import tracing required.
- MIT licensed, runs entirely on your machineNo cloud account, no data leaving the machine, no per-seat pricing. Runs as an Electron desktop app or served to a browser from localhost. The MCP server listens on localhost only. You own the installation and all data it processes, which is unlike paid AI coding platforms that route your codebase through external infrastructure.
- Test coverage visible in the review diffDrop an lcov.info file from vitest, jest, nyc, or pytest-cov into the project root and coverage data appears live in the graph lenses, hover cards, and the review risk score. The review cockpit distinguishes files that were never tested from files that were tested but then edited again without re-running verification.
- Agent activity attributed, not anonymousThe process tree of every terminal is watched for recognized agent processes: claude, codex, opencode, aider. File changes made while an agent runs are attributed to it with colored node rings and graph trails. Every shell command run in any terminal lands in a persistent commands log, labeled read, write, verify, network, or destructive.
Trade-offs
- -Very early project with a small communityFlare was created in August 2026 and has 105 GitHub stars. Documentation beyond the README is minimal, and the community for troubleshooting or extending the tool is small. For teams that need production-grade support, a large extension ecosystem, or battle-tested stability, an established IDE is the safer starting point.
- -Requires local agent executionFlare monitors terminals on the machine where it runs and cannot track agents executing in cloud environments or remote sandboxes. If your team uses a managed agentic coding service that runs agents on external infrastructure, Flare's change attribution and task-board integration will not reach those agents.
- -No extension marketplaceUnlike VS Code or JetBrains IDEs, Flare has no plugin or extension system. Customization beyond what the tool ships with requires forking the repository. Teams with workflow requirements outside the built-in feature set will need to wait for upstream development or maintain their own fork.
Flare vs alternatives#
Flare vs Gumloop
Gumloop is a commercial AI workflow platform that lets you build agent pipelines through a no-code visual editor in the browser. Flare is an open source IDE you run locally, where AI agents work directly on your filesystem while Flare maps and monitors every change. The tools serve different use cases: Gumloop targets teams automating business workflows through API integrations; Flare targets developers who want oversight of agents writing and reviewing code.
| Feature | Flare | Gumloop |
|---|---|---|
| License | MIT | Proprietary |
| Hosting | Local (Electron or browser) | Cloud-managed |
| Code-level oversight | Yes (graph, diff, risk triage) | No |
| Agent task board | Yes (kanban, MCP-queryable) | No |
| Target workflow | Agentic code editing | Business process automation |
Flare is the stronger choice when you need to see exactly which files an agent touched, review changes by blast-radius risk, and revert specific bursts to a known-good state. Gumloop is the better fit when you need to connect APIs, automate multi-step business processes, and prefer a managed cloud environment with no local setup.
Flare vs Make
Make (formerly Integromat) is a proprietary, cloud-hosted workflow automation platform built around visual scenario builders that connect web apps and services. Flare is an open source tool for a narrower, more technical use case: watching AI coding agents work on a local codebase and coordinating their tasks. The two tools do not directly compete in most workflows.
| Feature | Flare | Make |
|---|---|---|
| License | MIT | Proprietary |
| Hosting | Local | Cloud only |
| Primary use | Agentic code editing oversight | App and service integration |
| Agent integration | MCP server, terminal watcher | HTTP and webhook nodes |
| Self-hosting | Yes | No |
Make is the right choice when automating multi-step processes across SaaS tools (CRMs, email, spreadsheets, databases) without writing code. Flare is the right choice when your agents are writing code to your local filesystem and you need a visual map of the repo, a task board the agent can query, and a risk-tiered review of every change burst.
What it's built on#
- Languages
- JavaScriptTypeScript
- Frameworks
- React
- Tooling
- esbuild
FAQ#
Is Flare free to use?
Yes. Flare is MIT licensed and free to run on your own machine. There is no managed cloud tier, no account required, and no per-seat cost. You run it as an Electron desktop app or serve it to a browser from the machine where your agent executes.
Which AI coding agents does Flare work with?
Flare works with any agent that runs in a terminal on your local machine. It detects claude, codex, opencode, and aider by watching the process tree in its terminals and attributes file changes to the running agent. The MCP server integration is compatible with any MCP-capable client, including Claude Code.
How does Flare's shadow history work?
Flare auto-commits every burst of file changes to a hidden git repository using a separate GIT_DIR, so your real repository is never touched. The timeline panel lists every snapshot; you can diff any file against any past state or restore the whole working tree. Your normal git branches, commits, and history are unaffected.
Can multiple agents work on the same project at once?
Yes. Flare's task board is built for concurrent agents: a card is only offered if it is still in the first lane, and moving it to in-progress claims it so no other agent is pointed at it. Concurrent writes to the board are rebased rather than dropped. The panel and all agents share one consistent view of the board.
Does Flare replace my existing code editor?
Flare includes a Monaco editor (the same editor used in VS Code) with syntax highlighting, multiple terminals, and a file tree. It is designed as a standalone environment for agentic coding sessions rather than a plugin for an existing editor. Whether you use it as your primary editor or only during agent-assisted sessions depends on your workflow.
Similar open-source tools#
Node-RED
Low-code event-driven programming with a browser-based editor
Automatisch
Self-hosted Zapier alternative for workflow automation
Windmill
Developer platform for scripts, automations, and internal tools
Huginn
Self-hosted agents that watch the web and trigger automations
Activepieces
Build AI-powered automations and agents without vendor lock-in
discli
CLI for building AI agents and automating Discord servers