How does Atlas handle .NET project and solution files?

Atlas is designed to work direct within .NET solutions. When you run Atlas in a directory containing a `.sln` or `.csproj` file, it automatically reads and understands your project references, `NuGet` package dependencies, and configurations for tools like `dotnet format`. This allows Atlas to build an accurate mental model of your .NET application's structure and dependencies, enabling precise semantic searches and code navigation. It can even suggest adding an `xUnit` test or an endpoint to an ASP.NET Core application, understanding the context of your existing project files.

Can Atlas help me understand `NuGet` package dependencies?

Yes, Atlas helps you understand `NuGet` package dependencies. By reading your `.csproj` files, Atlas identifies all `PackageReference` entries and project-to-project references. When you use `codebase_search` or `glob`, Atlas can surface information related to these dependencies. For instance, you could ask 'where is `Microsoft.EntityFrameworkCore` used?' or 'list all `NuGet` packages in `src/MyWebApp.csproj`'. This capability is crucial for understanding external libraries and their impact on the codebase, without needing to manually inspect every `packages.config` or `csproj` file.

How does Atlas integrate with .NET testing frameworks like xUnit?

Atlas integrates directly with .NET testing frameworks like `xUnit` through the `dotnet test` command. When onboarding, you can use Atlas to explore existing `xUnit` tests to understand functionality. For example, you could ask `codebase_search` 'show me authentication tests' or use the `explore` subagent to 'find all `xUnit` test files'. Atlas can also propose adding new `xUnit` tests, generating the necessary C# code and integrating it into your test project, then presenting a unified diff for your approval before running `dotnet build` or `dotnet test`.

What specific .NET commands does Atlas use or understand?

Atlas understands and can interact with core .NET commands. It recognizes the structure of projects managed by the `.NET SDK`, including `dotnet build`, `dotnet run`, `dotnet test` (for `xUnit`), and `dotnet format`. While Atlas itself is an AI agent, it can leverage these commands through its `bash` tool, always permission-gated. For instance, it can suggest running `dotnet format` to adhere to code style or execute `dotnet test` to validate changes, presenting the output back to you in the terminal.

How does Atlas ensure my .NET code stays private?

Atlas prioritizes the privacy of your .NET code. It can build its code index using local Ollama embeddings, ensuring that your proprietary C# source code, `.csproj` files, and `NuGet` package details never leave your local machine or third-party servers. Every Atlas tool call, including those that might interact with your file system or external services, is permission-gated against `allow`, `ask`, and `deny` rules, giving you granular control over what Atlas can access and where your .NET codebase information goes.

Can Atlas help with ASP.NET Core specific patterns?

Yes, Atlas is designed to assist with ASP.NET Core specific patterns. It can read your minimal APIs, understand Dependency Injection (DI) container configurations, and analyze project references within your `.csproj` files. You can ask `codebase_search` questions like 'how are API endpoints defined?' or 'where is the `IConfiguration` injected?'. Atlas can even propose adding a new endpoint to an ASP.NET Core application, generating the C# code and presenting it for your review, demonstrating its deep understanding of the framework's idioms.

Onboard to an Unfamiliar .NET Codebase with Atlas in 2026

In 2026, Atlas helps .NET developers build a working mental model of unfamiliar codebases by leveraging semantic search, analyzing project references in `.csproj` files, and exploring `xUnit via dotnet test` outputs to quickly grasp system architecture and functionality without reading every file.

How does Atlas understand .NET code structure?

Atlas begins understanding a .NET codebase by indexing its Abstract Syntax Tree (AST) declarations, not just blind line windows, allowing it to grasp the semantic meaning of C# code. This approach, available in 2026, ensures Atlas comprehends the relationships between types, methods, and project references within your `.sln` and `.csproj` files.

To build a working mental model of an unfamiliar .NET repository, Atlas first constructs a robust index of the codebase. Unlike traditional keyword search, Atlas uses tree-sitter to parse C# code into its AST declarations. This means Atlas understands the structure of your classes, interfaces, and methods, and how they relate to each other, rather than just matching text strings. When you run Atlas in a solution containing `.sln` or `.csproj` files, it automatically reads these project definitions, including your minimal APIs, Dependency Injection (DI) container configurations, and project references. This deep understanding allows Atlas's `codebase_search` tool to query the semantic index for concepts like 'how requests are authenticated' or 'where is the `IUserService` implemented', returning highly relevant C# code snippets and their file paths, such as `src/MyWebApp/Services/UserService.cs` or `tests/MyWebApp.Tests/AuthTests.cs`.

How do I explore .NET project layout and dependencies?

Exploring the top-level directories of a .NET solution is crucial for understanding its package layout and naming conventions, a task Atlas simplifies in 2026. The `glob` tool quickly reveals the structure, showing common patterns like `src/`, `tests/`, and `tools/`, alongside specific `.sln` and `.csproj` files.

After an initial semantic search, understanding the physical layout of a .NET repository is the next step. The `glob` tool in Atlas allows you to quickly map the directory shape and identify naming conventions without opening individual files. For instance, running `glob */` might reveal `src/`, `tests/`, `docs/`, and `MySolution.sln`. This immediately tells you about the project's organization. You can then use `glob src/**/*.csproj` to discover all C# project files, like `src/MyWebApp/MyWebApp.csproj` or `src/MyLibrary/MyLibrary.csproj`, which are critical for understanding project dependencies and `NuGet` package references. Atlas reads these `.csproj` files to understand how projects reference each other and which `NuGet` packages are installed, providing a concrete view of the dependency graph. This is far more efficient than manually navigating the file system or inspecting every `packages.config` or `PackageReference` entry.

How does Atlas help me dive into specific .NET files?

Diving into specific .NET files and following their dependencies is streamlined by Atlas's `read` and `lsp` tools, a powerful combination for 2026 .NET development. After `codebase_search` identifies key files, `read` fetches their content, and `lsp` allows you to `goToDefinition` for types and methods, tracing the flow of execution.

Once `codebase_search` has identified the two or three most relevant C# files, such as `Controllers/AuthController.cs` or `Startup.cs`, you can use the `read` tool to pull their content directly into your terminal. This allows for focused review of the most critical code snippets. To build a deeper mental model, Atlas integrates with the Language Server Protocol (LSP) through its `lsp` tool. This means you can follow imports and navigate code definitions just as you would in a sophisticated IDE. For example, if you're reading `AuthController.cs` and encounter a call to `_userService.AuthenticateUser()`, you can use `lsp goToDefinition` to jump directly to the definition of `AuthenticateUser` within `UserService.cs`, even if it's in a different project. This capability is essential for understanding how different components of an ASP.NET Core application interact, from routing and middleware to data access and business logic, without having to manually search for file paths or class definitions.

How does Atlas safely explore a large .NET codebase?

For wide sweeps across a large .NET codebase, Atlas delegates to the `explore` subagent, ensuring safe, read-only operations in 2026. This subagent is configured with a deny-by-default permission set, allowing it to use tools like `grep`, `glob`, and `read` to gather information without risking unintended modifications to your `.sln` or `.csproj` files.

When you need to perform broader investigations across an unfamiliar .NET codebase, such as finding all usages of a particular interface or identifying all `xUnit` test files, Atlas leverages its `explore` subagent. You can delegate these wide sweeps using the `task` tool. The `explore` subagent operates with a strict deny-by-default permission set, meaning it can only execute explicitly allowed tools. For onboarding, this typically includes `grep` for pattern matching across files, `glob` for directory structure analysis, `read` for file content retrieval, `bash` for executing safe shell commands like `dotnet test --list-tests`, `webfetch` for documentation, and `websearch` for external context. This read-only environment ensures that while the subagent is looking around, it cannot accidentally modify any C# source files, `.csproj` configurations, or `NuGet` package references, providing a secure way to gather comprehensive information about the repository.

How does Atlas ensure safety and review for .NET changes?

Atlas ensures safety and review for any proposed .NET changes through a multi-stage approval process, a core feature in 2026. Before any file is modified, Atlas drafts a plan in a read-only agent, computes a unified diff for every edit, and surfaces it for your explicit approval, protecting your C# code and `.csproj` files.

Safety and review are paramount when making changes to an unfamiliar .NET codebase. Atlas incorporates several layers of protection. First, every Atlas tool call is permission-gated, requiring your explicit `allow`, `ask`, or `deny` approval before execution. Second, Atlas drafts a comprehensive plan in a read-only plan agent, detailing its intended actions, before switching to a build agent that can make modifications. This allows you to review the strategy before any changes are attempted. Third, for every file edit, Atlas computes a unified diff, presenting it to you for approval. This means you see exactly what C# code, `.csproj` settings, or `NuGet` package references Atlas proposes to change, such as adding an endpoint to an ASP.NET Core application or an `xUnit` test. You can then approve or reject the diff. Atlas also snapshots file changes as git patches, allowing edits to be easily diffed and rolled back, providing a robust safety net for your .NET development workflow.

Step by step

01Run `atlas` in your .NET solution directory, ensuring a `.sln` or `.csproj` file is present for Atlas to index your C# code and project references.
02Ask `codebase_search` a plain-language question, such as 'how are requests authenticated in this ASP.NET Core application?', to query the semantic index and retrieve ranked C# snippets with file paths like `src/MyWebApp/Controllers/AuthController.cs`.
03Run `glob */` to inspect the top-level directories and understand the .NET package layout and naming conventions, then use `glob **/*.csproj` to identify all C# project files and their `NuGet` dependencies.
04Use `read` on the two or three highest-ranked C# files from `codebase_search`, then follow method and type definitions with `lsp goToDefinition` to trace execution flow within the .NET codebase.
05Delegate wide sweeps to the `explore` subagent using the `task` tool, for example, 'task find all `xUnit` tests' or 'task grep for `IConfiguration` usage', knowing it operates in a read-only mode with tools like `grep`, `glob`, and `read`.
06Record your findings and open questions as a `todowrite` list, ensuring that your newly built mental model and any remaining uncertainties are preserved for subsequent Atlas turns or `dotnet build` cycles.

Frequently asked questions

How does Atlas handle .NET project and solution files?: Atlas is designed to work direct within .NET solutions. When you run Atlas in a directory containing a `.sln` or `.csproj` file, it automatically reads and understands your project references, `NuGet` package dependencies, and configurations for tools like `dotnet format`. This allows Atlas to build an accurate mental model of your .NET application's structure and dependencies, enabling precise semantic searches and code navigation. It can even suggest adding an `xUnit` test or an endpoint to an ASP.NET Core application, understanding the context of your existing project files.
Can Atlas help me understand `NuGet` package dependencies?: Yes, Atlas helps you understand `NuGet` package dependencies. By reading your `.csproj` files, Atlas identifies all `PackageReference` entries and project-to-project references. When you use `codebase_search` or `glob`, Atlas can surface information related to these dependencies. For instance, you could ask 'where is `Microsoft.EntityFrameworkCore` used?' or 'list all `NuGet` packages in `src/MyWebApp.csproj`'. This capability is crucial for understanding external libraries and their impact on the codebase, without needing to manually inspect every `packages.config` or `csproj` file.
How does Atlas integrate with .NET testing frameworks like xUnit?: Atlas integrates directly with .NET testing frameworks like `xUnit` through the `dotnet test` command. When onboarding, you can use Atlas to explore existing `xUnit` tests to understand functionality. For example, you could ask `codebase_search` 'show me authentication tests' or use the `explore` subagent to 'find all `xUnit` test files'. Atlas can also propose adding new `xUnit` tests, generating the necessary C# code and integrating it into your test project, then presenting a unified diff for your approval before running `dotnet build` or `dotnet test`.
What specific .NET commands does Atlas use or understand?: Atlas understands and can interact with core .NET commands. It recognizes the structure of projects managed by the `.NET SDK`, including `dotnet build`, `dotnet run`, `dotnet test` (for `xUnit`), and `dotnet format`. While Atlas itself is an AI agent, it can leverage these commands through its `bash` tool, always permission-gated. For instance, it can suggest running `dotnet format` to adhere to code style or execute `dotnet test` to validate changes, presenting the output back to you in the terminal.
How does Atlas ensure my .NET code stays private?: Atlas prioritizes the privacy of your .NET code. It can build its code index using local Ollama embeddings, ensuring that your proprietary C# source code, `.csproj` files, and `NuGet` package details never leave your local machine or third-party servers. Every Atlas tool call, including those that might interact with your file system or external services, is permission-gated against `allow`, `ask`, and `deny` rules, giving you granular control over what Atlas can access and where your .NET codebase information goes.
Can Atlas help with ASP.NET Core specific patterns?: Yes, Atlas is designed to assist with ASP.NET Core specific patterns. It can read your minimal APIs, understand Dependency Injection (DI) container configurations, and analyze project references within your `.csproj` files. You can ask `codebase_search` questions like 'how are API endpoints defined?' or 'where is the `IConfiguration` injected?'. Atlas can even propose adding a new endpoint to an ASP.NET Core application, generating the C# code and presenting it for your review, demonstrating its deep understanding of the framework's idioms.

Try Atlas in your terminal

The terminal-native AI coding agent. Free core, single binary.

Install Atlas

Related guides

Onboard to an Unfamiliar Codebase with Atlas in 2026

How to onboard to an unfamiliar codebase with Atlas in 2026: use codebase_search, glob, read, lsp, task, and todowrite to build a mental model fast.

Atlas for .NET: Your AI Coding Agent in 2026

Atlas empowers .NET developers in 2026 with a terminal-native AI coding agent. Securely integrate Atlas with ASP.NET Core for web APIs and services, leveraging local embeddings and robust safety features for efficient

Write Unit Tests for Untested Code in .NET with Atlas in 2026

In 2026, Atlas helps .NET developers add robust xUnit tests to untested modules, automatically matching existing repo conventions and integrating with dotnet test and NuGet.

Automate GitHub Issue and Pull Request Triage in .NET with Atlas in 2026

Streamline GitHub issue and pull request triage for your .NET projects using Atlas in 2026. Integrate with GitHub Actions, leverage real .NET tools like NuGet and dotnet test, and ensure secure, permission-gated

Self-review your working diff before committing in .NET with Atlas in 2026

In 2026, .NET developers use Atlas to self-review uncommitted diffs, catching mistakes before CI. Leverage `dotnet test`, `dotnet format`, and `NuGet` with AI assistance.

Run the Test Suite and Triage Failures in .NET with Atlas in 2026

In 2026, Atlas helps .NET developers efficiently triage xUnit test failures. Turn a wall of red output from `dotnet test` into a prioritized list of distinct root causes.

Extract a Shared Helper from Duplicated .NET Code with Atlas in 2026

Refactor duplicated logic in your .NET codebase by extracting shared helpers with Atlas. Leverage semantic search, automated file creation, and atomic patch application for a streamlined workflow in 2026.

Research a Third-Party API Before Integrating it in .NET with Atlas in 2026

Streamline third-party API research for .NET integrations in 2026 with Atlas. Discover how Atlas uses websearch and webfetch to get current API shapes, ensuring your ASP.NET Core services are built on accurate

Browse this resource hub