Local .NET context for coding agents

Persistent semantic index and compiler verification for .NET agents

Fuse indexes a solution through MSBuild and Roslyn, reuses that work across agent turns, resolves .NET wiring from a typed graph, returns reduced source for a selected scope, and checks proposed C# files against compiler state.

Connect Fuse Quickstart

shell

# Install the .NET global tool
$ dotnet tool install -g Fuse

# Connect to your coding agent
$ fuse mcp install --rules

1.8 ms

Exact symbol lookup

Median on the recorded NodaTime semantic index with 14,760 symbols; timings depend on the machine.

15.7 ms

Task localization

Median warm lookup on the same NodaTime run; open-ended recall is reported separately on the benchmarks page.

38-44%

Skeleton token reduction

Recorded across four repositories while retaining every measured public and protected type name.

False-green checks

Zero false green and zero false red across 1,000 compiler-labeled mutation edits on the recorded OrderingApp set.

Any MCP client, including Cursor, Claude Code, and Copilot. Apache 2.0. Analysis runs locally and can work offline.

Persistent discovery

One index reused across agent turns

File reads, grep, and regex can reconstruct the same symbols, references, and project structure several times during a task. Fuse stores that discovery in SQLite and updates changed files incrementally. Syntax mode provides symbols and source chunks; semantic mode adds DI registrations, handlers, routes, options, and call edges.

Index the solution

The shared daemon starts warming .fuse/fuse.db when the repository is served. Later calls reuse the store, and changed files re-index incrementally.

Resolve .NET wiring

Resolve a service interface to its registered implementation, a route to its action, or a request to its handler through recorded framework relationships.

Return reduced source

Select source from indexed anchors, reduce it under a token budget, and include provenance so the agent receives the code needed for the current scope.

Text search

IOrderService appears in 14 files

fuse_find kind=service

Registered implementation: OrderServiceConstructor injection in CheckoutHandler3 direct callers in production code

Grep finds the interface name. Fuse walks the DI registration to the type that runs.

Pipeline detail: index, localize, resolve, expand, plan, render.

Indexed discovery and compiler checks

A local task path for reading and changing .NET code

Fuse runs beside your editor on the solution already on disk. The coding agent remains responsible for the change. Fuse supplies indexed answers, reduced source, and graded compiler results at the points where they are useful.

1
Survey the workspace
Map symbols, routes, and counts with fuse_workspace or rank candidate files for a task with fuse_find.
2
Resolve wiring
Trace a service, request, route, or config section to the code that handles it. No source bodies yet.
3
Read focused context
fuse_context emits reduced source with a manifest explaining why each file was included. Sessions skip repeats across turns.
4
Propose and check
Send proposed file content to fuse_check before writing. Revise from compiler diagnostics and repair packets.
5
Measure blast radius
Call fuse_impact before a public signature change. Run covering tests with fuse_test, not the whole suite.
6
Review the branch
fuse_review seeds on the git diff and packs related callers, handlers, and tests under a token budget.

Daily .NET work

MCP tools for .NET agent workflows

Check a proposed change

Typecheck a single-file edit before it is written. If the compiler rejects it, the agent gets the errors and can revise the proposal.

Example: report a missing constructor argument before Program.cs changes.

Find the code that actually runs

Trace a registered service, request, route, or configuration section to its implementation, handler, action, or options class.

Example: resolve POST /checkout to CheckoutCommandHandler.Handle.

See callers before changing a signature

List callers, implementations, and referencing types before a method or interface changes.

Example: find every use of IOrderService.PlaceAsync before adding a parameter.

Run the relevant tests

Select and run the test types connected to the changed symbol instead of starting with the entire test suite.

Example: run CheckoutHandlerTests after changing the checkout handler.

Stage a verified refactor

Rename a symbol, change a parameter list, or apply a code fix. The refactor comes back as a diff only when the compiler reports no new diagnostic.

Example: add a CancellationToken parameter and update every call site.

Check a package upgrade

Give Fuse a NuGet package id and two versions. It returns the code in your solution that the upgrade would break.

Example: see what breaks before moving Polly from 7.x to 8.x.

See the tool reference for command shapes, limits, and result fields.

Related tools

Code indexes and graphs are an existing category

CodeGraphContext builds a local multi-language code graph, Serena exposes language-server-backed symbol operations, and Sourcegraph provides code search and navigation across repositories. Fuse concentrates on local .NET work through MSBuild and Roslyn: framework wiring, reduced scoped source, proposed-file compiler checks, change impact, and covering-test selection. It can run alongside a coding client's built-in index or another search tool.

The bounded peer comparison records its sample sizes and limits. It is not a general ranking of these tools.

Compared on the recorded corpus

Recorded corpus comparisons

Rows from the benchmark suites on pinned repositories. They describe that sample, not every .NET project.

Question

Grep or write-then-build

Fuse (recorded)

Which implementation runs for this interface?

Finds the interface name, not the DI registration

24 of 24 wiring edges on OrderingApp; 0 false positives

What context does this branch need?

67% changed-file recall, 8% precision (grep baseline on 69 PRs)

93.4% precision, median 1,026 returned tokens; changed files kept by construction

Will this proposed file compile?

Write the file, then run dotnet build

fuse_check before write; 0 of 1,000 compiler-labeled edits reported clean when broken

Did the agent finish correctly?

82% pass@1 on scored rollouts; 9 false-done

89% pass@1; 8 false-done; build+test counts 3.1 vs 3.2 (essentially equal)

Recorded results

Honest checks on a defined sample

The 1,000-edit compiler gate generated 500 breaking and 500 neutral single-file edits over OrderingApp and compared Fuse's verdict to the compiler label. Fuse reported every breaking edit and rejected none of the neutral edits.

The agent-loop run scored edits against each task's own tests after the agent finished. Fuse passed on the first attempt in 89 percent of scored rollouts versus 82 percent for native tools, with overlapping confidence intervals. Fuse declared success on a failing edit 8 times versus 9. Agent-visible build and test calls were 3.1 versus 3.2, so the measured edge is fewer wrong finishes, not half the builds.

Read the methods, weaker modes, and reproduction commands on the benchmarks page.

500 of 500

Breaking edits reported

500 of 500

Neutral edits accepted

89%

pass@1, Fuse arm (scored rollouts)

1,026

Median review tokens on 69 PRs

Runtime and verification behavior

Local analysis with graded compiler results

Fuse is a .NET 10 global tool. Any MCP-compatible agent connects through the protocol, including Cursor, Claude Code, Copilot, and others. Source and the derived index stay on your machine. Analysis can work offline; the optional update check and repository package feeds are the network-dependent exceptions. Read and check operations do not change working files unless you call the explicit apply path.

Skeleton reduction removed 38 to 44 percent of tokens on four recorded repositories while keeping every public and protected type name and 96.3 to 99.4 percent of method names. That keeps survey and context calls smaller than returning whole files.

Verification grades

Every answer names how it was produced. Oracle grade checks against compiler state captured from the real build. Build grade runs a scoped dotnet build and returns those diagnostics. If neither path can run, Fuse abstains and names what is missing instead of guessing.

The opt-in resident workspace answers repeated fuse_check calls in about 31 ms at the median on the recorded NodaTime run. That path does not replace normal builds or tests before merge.

Open-ended file ranking from a title alone recalls 37.7 percent of changed files on the recorded corpus. Anchor on Git, a symbol, a route, or a service when you can.