Atlas is a terminal-native AI coding agent that works on F# solutions in 2026. Atlas reads compilation order straight from the .fsproj file, because F# compiles in file order, and it maps your discriminated unions, modules, and any Giraffe or Fable entry points before proposing a change. Atlas runs dotnet test behind a permission prompt, shows a unified diff for approval, and runs Fantomas over the changed .fs files.
Why F# developers use Atlas
F# developers use Atlas because F# compiles in file order, and Atlas reads that order from the .fsproj rather than guessing. Atlas indexes code by AST declarations using tree-sitter, so a search for a discriminated union in 2026 returns the union, not a random usage.
File order is the trap that catches most tooling in F#. A helper defined below its consumer does not compile, so an agent that inserts a new module in the wrong position produces a solution that fails before a single test runs. Atlas reads the compile ordering from the project file and works within it. Beyond ordering, Atlas searches code with hybrid semantic and keyword retrieval fused by reciprocal rank fusion, so asking where a Result is mapped finds the pipeline that does it. Because Atlas indexes by AST declarations, a query about a computation expression lands on the builder type, which is the context needed to extend it correctly.
Working in F# day to day with Atlas
Day to day in F#, Atlas maps your discriminated unions, modules, and any Giraffe or Fable entry points before editing. Ask Atlas in 2026 to replace a null check with an Option pipeline or to add Expecto tests to the test project, and Atlas drafts the plan first in a read-only plan agent.
A typical F# request is small in text and large in consequence: replace a null check with an Option pipeline, and the change ripples through every caller that assumed a nullable. Atlas drafts a plan in a read-only plan agent and asks before switching to a build agent, so you see the Option pipeline, the callers that must now match on Some and None, and the new Expecto tests, all before the working tree changes. Because Atlas has mapped your Giraffe or Fable entry points, it knows whether a change sits in an HTTP handler or in code that will be compiled to JavaScript. Atlas can fan out work to subagents that run in the foreground or in parallel background sessions when several projects in the solution need the same fix.
Running dotnet test behind a permission prompt
Atlas can run dotnet test on your F# solution in 2026, but every Atlas tool call is permission-gated against allow, ask, and deny rules before it runs. You allow dotnet test, Atlas runs the Expecto suite, reads the failures, and iterates before it asks to commit anything.
The F# compiler catches most mistakes, and dotnet test catches the rest, so Atlas is built to lean on both. When Atlas runs dotnet test behind a permission prompt, incomplete pattern match warnings and failing Expecto assertions come back as structured feedback that shapes the next iteration rather than as text the agent ignores. Permission rules are the control surface: allow dotnet build and dotnet test, ask before Atlas touches the .fsproj file order or adds a NuGet reference, and deny the rest. Nothing runs without a rule that allows it, which is what makes the loop safe to leave running while you read the plan.
Reviewing the diff and running Fantomas
Atlas computes a unified diff for every file edit and surfaces it for approval before writing, so in 2026 no .fs file changes without your review. Atlas runs Fantomas over the changed .fs files, and it snapshots file changes as git patches so any edit can be diffed and rolled back.
Review in F# is mostly about indentation and ordering, because both carry meaning. Running Fantomas over the changed .fs files before you look means the diff shows the semantic change and not a re-indentation of the surrounding module. Atlas snapshots file changes as git patches, so an Option refactor that turned out to break a Fable build can be rolled back cleanly rather than reverted by hand. Atlas also reads git branches, status, and diffs, and can stage and create commits on your behalf once you approve, so the commit reflects the change you actually reviewed and the .fsproj edits that came with it.
Local indexing and extending Atlas on F# codebases
Atlas can build its code index with local Ollama embeddings, keeping code off third-party servers, which matters for the finance and insurance teams where F# is common. Atlas also connects to Model Context Protocol servers and exposes their tools to the agent in 2026.
F# has a strong footprint in domains where source cannot leave the network. Atlas can build its code index with local Ollama embeddings, so embedding your .fs files happens on hardware you control. Atlas is extensible through plugins that contribute tools and hook into agent lifecycle events, which lets a team add its own project templates or internal validation steps to the loop. Atlas connects to Model Context Protocol servers and exposes their tools to the agent, and Atlas lets you switch the active model and provider on the fly with favorites and recents, so a routine test-writing pass and a hard type-inference problem do not have to share a model.
Getting started
- 01Run atlas in a solution with an .fsproj (F# compiles in file order, and Atlas reads that order from the project file)
- 02Let Atlas map your discriminated unions, modules, and any Giraffe or Fable entry points
- 03Ask Atlas to replace a null check with an Option pipeline or add Expecto tests to the test project
- 04Let Atlas run dotnet test behind a permission prompt, then review the diff before it commits
- 05Have Atlas run Fantomas over the changed .fs files
Frequently asked questions
- does atlas understand f# file order in fsproj
- Yes. F# compiles in file order, and Atlas reads that order from the .fsproj project file, so a new module is placed where it will actually compile.
- can an ai coding agent run dotnet test on an f# project
- Yes. Atlas runs dotnet test behind a permission prompt, reads the failing Expecto assertions, and iterates before it asks to commit.
- how do i replace null checks with option in f#
- Ask Atlas to replace a null check with an Option pipeline. Atlas plans the change, updates the callers, and surfaces a unified diff for your approval.
- does atlas format f# code with fantomas
- Yes. Atlas runs Fantomas over the changed .fs files so the diff you review reflects the semantic change instead of re-indentation.
- can atlas work with giraffe or fable projects
- Atlas maps your discriminated unions, modules, and any Giraffe or Fable entry points, so its plan accounts for whether a change lives in an HTTP handler or in code compiled to JavaScript.
- is atlas safe on a private f# codebase
- Atlas can build its code index with local Ollama embeddings, keeping code off third-party servers, and every tool call is permission-gated against allow, ask, and deny rules.
- can atlas add expecto tests to my test project
- Yes. Ask Atlas to add Expecto tests to the test project, review the unified diff, then let Atlas run dotnet test to prove they pass.
Try Atlas in your terminal
The terminal-native AI coding agent. Free core, single binary.
Install AtlasRelated guides
Review a Pull Request in F# with Atlas in 2026
In 2026, F# developers use Atlas to review pull requests, leveraging its deep understanding of .fsproj files, discriminated unions, and dotnet test (Expecto) to catch subtle bugs.
Run Atlas Headless in CI for F# Projects in 2026
F# developers in 2026 can run Atlas headless in CI pipelines to automate code tasks. Get machine-readable output, integrate with dotnet test (Expecto), NuGet, and fantomas for robust F# development.
Automate GitHub Issue and Pull Request Triage in F# with Atlas in 2026
Streamline GitHub issue and pull request triage in your F# projects with Atlas in 2026. Leverage Atlas's AI to respond safely, run dotnet test (Expecto), and format with fantomas for trusted F# workflows.
Extract a Shared Helper from Duplicated F# Code with Atlas in 2026
Refactor F# code in 2026 by extracting duplicated logic into a shared helper using Atlas. Leverage semantic search, automated refactoring, and F#-specific toolchain integration for clean, tested code.
Audit an F# Repository with Parallel Subagents in Atlas in 2026
Audit F# repositories in 2026 with Atlas's parallel subagents. Sweep code for problems using `dotnet test (Expecto)` and `fantomas` without blowing your main session's context window.
Write unit tests for untested code in F# with Atlas in 2026
In 2026, Atlas helps F# developers add unit tests to existing modules, respecting .fsproj file order and using dotnet test (Expecto) and Fantomas.
Upgrade a Dependency and Fix Breakage in F# with Atlas in 2026
Upgrade F# dependencies in 2026 with Atlas. direct bump NuGet packages, fix compile errors, and repair Expecto test failures using dotnet add package and fantomas for a smooth migration.
Document a module with a README in F# with Atlas in 2026
Generate accurate, up-to-date READMEs for your F# modules using Atlas in 2026. Atlas leverages your .fsproj and real code to document public APIs, ensuring documentation reflects current implementation, not outdated