# Fuse

> Local MCP server for .NET that provides persistent semantic indexing via MSBuild and Roslyn, DI wiring resolution, reduced task-scoped source, and pre-write compiler verification for coding agents.

Fuse is a local .NET global tool and MCP server built by Litenova Solutions that gives coding agents a persistent semantic index of a .NET solution, typed-graph wiring resolution, and pre-write compiler verification — all running on the developer's machine without sending source to a remote service. It is released under the Apache 2.0 license and available on NuGet and GitHub.

## What It Is

Fuse sits between a coding agent (Cursor, Claude Code, GitHub Copilot, and others) and a .NET solution on disk. Instead of letting the agent rediscover symbols, registrations, and project structure through repeated file reads and text searches, Fuse indexes the solution once through MSBuild and Roslyn, stores the result in a local SQLite database (`.fuse/fuse.db`), and reuses that work across agent turns. It exposes its capabilities through the Model Context Protocol (MCP), so any MCP-compatible client can connect with two shell commands.

## How the Persistent Index Works

Fuse's shared local daemon begins warming the index when the repository is served, before the first tool call. The index operates in two tiers:

- **Syntax mode** — symbols and source chunks, available for any project that loads
- **Semantic mode** — adds DI registrations, request handlers, routes, options bindings, and call edges when the project loads through Roslyn

Changed files re-index incrementally; a cold read reports when the semantic upgrade is still running. The index is stored at repository root and shared across nested source folders. Every MCP operation except `fuse_reduce` requires a Git repository identity; non-Git folders return an error without starting a daemon.

## MCP Tool Surface

Fuse exposes a set of named MCP tools that map to distinct agent workflow steps:

- **`fuse_workspace` / `fuse_find`** — survey symbols, routes, and counts; rank candidate files for a task
- **`fuse_context`** — return reduced source with a manifest explaining why each file was included; sessions skip repeats across turns
- **`fuse_check`** — typecheck proposed single-file content against compiler state before writing; returns diagnostics and repair packets without touching the working tree
- **`fuse_impact`** — list callers, implementations, and referencing types before a signature change; also returns the break set for a NuGet package upgrade between two versions
- **`fuse_refactor`** — stage a rename or parameter-list change as a diff, returned only when the compiler reports no new diagnostic
- **`fuse_test`** — select and run the test types connected to the changed symbol instead of the whole suite
- **`fuse_review`** — seed on the git diff and pack related callers, handlers, and tests under a token budget with provenance

Every answer names its **verification grade**: oracle grade checks against compiler state captured from the real build; build grade runs a scoped `dotnet build`; when neither path can answer, Fuse abstains and names the missing prerequisite.

## Recorded Benchmark Results

The project publishes benchmark results from pinned repositories with reproduction commands. Key figures from those recorded runs:

- Across 1,000 compiler-labeled edits on the OrderingApp test app (500 breaking, 500 neutral), `fuse_check` reported zero broken edits as clean and rejected zero valid edits
- All 24 expected .NET wiring links matched with no extra matches on the same app
- Across 69 recorded pull requests, branch review retained every git-changed file at 93.4% precision with a median response of 1,026 tokens
- Skeleton reduction removed 38–44% of tokens across four repositories while retaining every public and protected type name and 96.3–99.4% of method names
- The opt-in resident workspace answered repeated `fuse_check` calls in 31.2 ms median on the recorded NodaTime run (14,760 symbols)

The project notes these measurements have defined limits and are not general rankings of code-intelligence tools.

## Update: Fuse v4.3.0

The latest release is v4.3.0, published on 2026-07-16. The GitHub repository shows active development with the last push on 2026-07-16 and CI running on the main branch. The installer supports seven MCP clients out of the box: Claude Code, Cursor, GitHub Copilot, OpenCode, Kilo Code, Codex, and Grok Build. The `--rules` flag writes the client's documented instruction file (such as `AGENTS.md` or `CLAUDE.md`), and `--with-hooks` separately writes project-scoped Claude Code hooks.

## Local and Write-Safe Design

Source, compiler state, git metadata, and the derived index all stay on the developer's machine. Read, check, impact, refactor, and review operations do not write the working tree. The one explicit tree-write path is `fuse_workspace` with `action=apply`, which is a dry run unless `write=true` is passed. Compiler-backed wiring analysis is .NET-only; other languages receive syntax-level search and reduction. The optional update check can contact NuGet, and build-grade operations can use the package feeds configured for the repository — those are the only network-dependent paths.

## Features
- Persistent semantic index via MSBuild and Roslyn stored in local SQLite
- Typed-graph DI wiring resolution (services, handlers, routes, options)
- Pre-write compiler verification with fuse_check without touching working tree
- Skeleton token reduction (38–44% reduction on recorded repositories)
- Git-seeded branch review with provenance under token budget
- Change impact analysis for signatures and NuGet package upgrades
- Covering-test selection and execution with fuse_test
- Staged refactoring as diff returned only when compiler reports no new diagnostic
- Incremental re-indexing of changed files
- Verification grades: oracle, build, and abstain modes
- Offline-capable local analysis
- Supports Claude Code, Cursor, GitHub Copilot, OpenCode, Kilo Code, Codex, Grok Build
- Resident workspace for fast repeated fuse_check calls (~31ms median)
- Write-safe: read/check/impact/refactor/review do not modify working tree

## Integrations
Claude Code, Cursor, GitHub Copilot, OpenCode, Kilo Code, Codex, Grok Build, MSBuild, Roslyn, NuGet, SQLite, Git, dotnet CLI

## Platforms
WINDOWS, API, CLI

## Pricing
Open Source

## Version
v4.3.0

## Links
- Website: https://fuse.codes
- Documentation: https://fuse.codes/docs
- Repository: https://github.com/Litenova-Solutions/Fuse
- EveryDev.ai: https://www.everydev.ai/tools/fuse-dotnet