SageFS

Load your project once. Your editor, your tests and your AI agent all ask the same live session.

F# Interactive is amazing. SageFs is FSI that already has your project loaded. Edit a function, saved or not, and the affected tests re-run. Save a file and the running app serves the new code, with its state still there. Every binding is on screen, live. Each session gets its own host process, built with whichever SDK dotnet picks in your project's folder, so your package versions never fight mine. It's free, it's MIT, and it's one daemon.

  • Your SDK, your packages
  • Every editor, one session
  • Tests on unsaved edits
  • Hot reload that says what it did
  • Free

installs with the .NET 10 SDK or the .NET 11 SDK · no config files · works on half-written code (source)

● Hot reload reaches into route tables that got built once at startup. That's the usual Falco/Giraffe/Saturn/Oxpecker setup, and it's what the demo below does. SageFS re-points the method, so a handler that gets called per request just reloads and the state you didn't touch stays where it is. How you start the app matters: one you start from FSI or an init script is patched in place by a detour, and one you start with run_app is patched in place by a metadata delta, the same call dotnet watch makes for C#. If the output was computed once at startup, you reshaped a type, or a run_app save needs something a delta can't take (a field added, a signature changed), you still need a restart, and SageFS tells you why. Live testing works across all five supported frameworks.

localhost:37749SageFs.Samples.WebappDatastar.fsproj
SageFS dashboard showing a live F# evaluation of the Falco/Datastar todo-list sample, with the session card and live bindings on the right
Save a file. The 0 below is the eval result. The right sidebar is the session: who's connected, what they're watching, and the next thing to try.

Hot Reload That Tells You The Truth

File watch → FSI eval → Harmony patch → SSE.

Save a file and SageFS re-points the running method with Harmony (source). Plain functions, functions in modules, static member bodies, and values bound straight to a lambda all reload in place, even when the route table was built once at startup (the usual Falco/Giraffe/Saturn/Oxpecker setup), and the state you haven't touched stays put. If you reshape a type, or change the type of a let mutable, that can't be patched, so SageFS says so and restarts, or asks for one. It patches the copy of a function your app is actually holding, including when a .SageFs/init.fsx #loaded your sources, on .NET 10 and .NET 11. An app you start with run_app runs in the worker, out of reach of a detour, so SageFS builds your project and hands the runtime a metadata delta, the same call dotnet watch makes for C#. The state stays put and a save comes back in a couple of seconds. A save the delta can't take (a field added, a signature changed) restarts the app and names the declaration. That path used to say Patched and change nothing. I caught it by editing the ticker demo and watching the output stay the same, and there's a test for it now. What each save did is also kept on the session, so your agent isn't left guessing: get_session_status carries a lastReload (patched, waiting to be seen running, never entered, restarted, kept a live value, no effect, restart required, or didn't compile, with the worker's own wording), and a push notification says it right after the save. For an app started with run_app, it reads Patched when the delta took the save and Restarted when it couldn't, which is the true answer either way. Getting the in-place part right meant reading the F# compiler's source. Turns out the Release optimizer was inlining small functions right out from under the patch, so SageFS builds your session without optimizations. The hot-reload docs have the full map.

Your Agent Gets a Real F# REPL

72 MCP tools, gated by session state.

SageFS runs a built-in MCP server with an affordance-driven state machine (source). Call a tool that doesn't fit the session's current state and it gets refused up front, so it doesn't blow up halfway through. Copilot, Claude, or any MCP client can evaluate F#, type-check it, and run the affected tests. It's the same REPL loop you use yourself, and a fast type-checked loop with tests re-running on every change is the best way I know to keep an agent from wandering off.

One Daemon, Every Maintained Client

Connect every client at the same time.

Start SageFS once. VS Code, Neovim, the Web Dashboard, and your AI agent all talk to the same daemon and the same session state at the same time. Each one keeps its own view, so the dashboard doesn't get yanked around every time another client switches sessions. I use this constantly.

See It Running

A live F# eval in the SageFS dashboard: a Falco/Datastar todo list, eval'd in milliseconds, with the session manager sitting right there on the side. One daemon, every editor.

SageFS dashboard showing a live F# evaluation of the Falco/Datastar todo-list sample, with the session card and live bindings on the right
The output panel is the last eval. The session card shows the browser that's connected, the project (SageFs.Samples.WebappDatastar), and what's loaded (9 namespaces, 2 live bindings).

Get Started

Prerequisite: the .NET 10 SDK or the .NET 11 SDK. The tool ships a build for each and dotnet picks the one that matches yours. You don't need anything else.

dotnet tool install --global SageFs
  1. Install. One command, no config files.

  2. Check (optional): sagefs check validates your SDK, FSI, project files, port, and daemon state.

  3. Start the daemon: run sagefs and it brings up the service and the Web Dashboard. You don't need a project yet. Your editor, MCP client, or the dashboard creates sessions when you ask.

  4. Connect through VS Code (Marketplace, Open VSX, or the .vsix from GitHub Releases), Neovim (sagefs.nvim), MCP (claude mcp add sagefs -- sagefs mcp, or your client's equivalent), or the Web Dashboard. Press Alt+Enter in an editor, or evaluate directly in the dashboard.

Three Workflows: REPL, Live Testing, Hot Reload

Every session picks one. The .NET runtime draws the line between REPL and Hot Reload. Once code is running, some things can be re-pointed in place and some just can't. The table says which is which.

REPL (default)Live TestingHot Reload
Type redefinitionFull: redefine types freelyFull: redefine types freelyFS0037: expression-level changes only
Browser hot reloadManual refresh requiredManual refresh requiredAuto-refresh; function-body changes propagate in place, including startup-captured route tables and values bound straight to a lambda. A reshaped type, or a mutable whose type changed, restarts the app instead
Live testingAvailable, you turn it onOn automatically when the session is ready: affected tests re-run on every edit from a connected editorAvailable, you turn it on
Best forPrototyping, domain modeling, explorationTDD: tests re-run as you typeWeb apps with Falco, Datastar, ASP.NET

Switch through the VS Code Command Palette (SageFs: Switch Workflow, the picker offers all three and marks which one you're in), the workflow dropdown on the dashboard, Neovim's :SageFsWorkflow (interactive, livetesting or hotreload, and with no name it opens a picker), or the switch_workflow MCP tool (accepts all three). VS Code, Neovim and the dashboard restart the same session in place. The MCP tool still creates a new session and stops the old one. I haven't unified those two paths yet. Either way, REPL-defined bindings are lost, but your files on disk are untouched.

Mental Model: Three Concepts

One daemon, every client: open full-screen (interactive: pan, zoom, focus, theme).

What You Get in Each Editor

CapabilityVS CodeNeovimWeb DashboardAI (MCP)
Eval / inline results✅✅✅✅
Live diagnostics (SSE)✅✅✅✅
Hot reload control✅✅✅✅
Session management✅✅✅✅
Code completion✅✅NoneHTTP
Live test gutters✅✅NoneNone
Coverage gutters✅✅NoneNone
Debug a failing test✅✅NoneNone
Failure narratives✅✅✅✅
Test panel✅✅✅✅
Type explorer✅✅None✅

None means nothing does it. HTTP means the editors reach it through a daemon route and no MCP tool does: completion is an F# Compiler Service call the editors make over HTTP. The editor columns say what's wired. Tests cover less than that.

Understanding the Gutter

Neovim draws these marks as signs in the sign column. VS Code draws the test marks at the end of the test's line and in the scrollbar's overview ruler, and the coverage marks as text in front of the code. The only icon VS Code puts in its own gutter is the Test Explorer run and debug glyph.

IconMeaning
✓ (green)Test passing: covered by at least one passing test
✗ (red)Test failing: a test covering this code has failed
○ (gray)No coverage: no test exercises this line
│ (green bar)Coverage healthy: all covering tests pass
│ (red bar)Coverage degraded: some covering tests are failing
│ (gray bar)Not covered: no test reaches this line
⊘Inline failure: test name and Expected/Actual diff

The $3,000/year Feature, Free

Visual Studio Enterprise wants about $250/month per seat for Live Unit Testing. SageFS goes after that same loop with a REPL at the center, and it's free and MIT licensed. All five supported test frameworks discover, run, and report correctly today. On the small F# sample I measured, a verdict on an edited function's test arrives about 0.7 seconds after the edit leaves the editor, with no save and no rebuild. That's one machine and one small project, so I can't promise it for every one.

VS Enterprise Live TestingSageFS
SpeedA build of a private copy of your repo for every editAbout 0.7 s from edit to verdict on one small F# sample
Broken codeMust compile firstTree-sitter works on incomplete code
ClientsVisual Studio onlyVS Code · Neovim · Web Dashboard · MCP
FrameworksMSTest · xUnit · NUnitExpecto · xUnit (v2 and v3) · NUnit · MSTest · TUnit
Price~$250/monthFree, MIT licensed

Under the Hood

Repository map

Where things live in the SageFS repo:

Troubleshooting

ProblemQuick Fix
Daemon not founddotnet tool install --global SageFs, then sagefs status
Port already in usesagefs stop, or set SAGEFS_MCP_PORT=8080 for the daemon you want to keep. --mcp-port 8080 alone is refused: a daemon off the default port has to name its owner with --owner-pid or when to give up with --ttl
Wrong project selectedSageFs: Switch Project in command palette
Stale REPL after changesSave the file first. Source edits auto-reload. Hard reset only for .fsproj / package changes.
Results don't match the code you just wroteYour daemon is older than your code. sagefs status shows when it started; restart it. A hard reset won't help.

Full troubleshooting and the complete MCP tool reference live in the documentation.

It's early days and I'm building this in the open, so you WILL find rough edges. Tell me about them. Hit me up on Discord (same name there) or open an issue on GitHub.

Read the documentation →
:SageTech --ready