How does Atlas handle Solidity dependencies installed by Soldeer?

Atlas fully integrates with Foundry projects, including libraries installed via `forge soldeer install`. Atlas builds its code index with these dependencies, allowing `codebase_search`, `grep`, and `lsp` tools to navigate and analyze code across your `src/` directory and all installed external contracts, providing a complete view of your Solidity codebase.

Can Atlas help me understand the gas cost impact of Solidity changes?

Yes, Atlas is designed with Solidity's unique requirements in mind. Before applying any proposed changes to your `src/` files, Atlas will run `forge snapshot` to compute and display the gas delta. This allows you to see the precise gas cost impact of the modifications, such as adding a reentrancy guard or converting a `require` string to a custom error, directly within your terminal for informed approval.

What specific Solidity files does Atlas index for search?

Atlas indexes all Solidity files within your Foundry project, primarily focusing on the `src/` directory for your contracts and any libraries installed by `forge soldeer`. It builds its code index using AST declarations, meaning it understands the structure of your contracts, storage layouts, modifiers, and functions, providing a more intelligent search than simple text matching.

How does Atlas ensure safety when modifying Solidity contracts?

Atlas employs a multi-layered safety approach for Solidity. It drafts plans in a read-only agent, asks for explicit permission before executing tools, and presents a unified diff for every file edit for your approval. Furthermore, for Solidity, it runs `forge snapshot` to show gas deltas and can apply `forge fmt` to maintain code style, ensuring transparency and control over all changes to your `src/` files.

Can Atlas help me write Solidity fuzz tests?

Yes, Atlas can assist in writing fuzz tests for your Solidity contracts. You can ask Atlas to write a fuzz test in your `test/` directory. After drafting the test, Atlas can run `forge test` behind a permission prompt, allowing you to verify the test's effectiveness and ensure your contract behaves as expected under various conditions, all within your Foundry environment.

How does Atlas's LSP tool benefit Solidity development?

Atlas's `lsp` tool is invaluable for Solidity developers. It allows you to use `workspaceSymbol` to jump directly to the declaration of any contract, function, or modifier by name, and `findReferences` to see every callsite. This is critical for understanding complex Solidity codebases, tracing execution flows, and refactoring, providing a symbol-aware navigation experience that goes beyond simple text search.

Locate Where a Behavior is Implemented in Solidity with Atlas in 2026

In 2026, Atlas empowers Solidity developers to precisely locate where a specific behavior is implemented within a Foundry project, even when only the functional outcome is known, not the code's name. Atlas integrates deeply with the Solidity toolchain, leveraging `forge test` for verification, `soldeer` for dependency management, and `forge fmt` for code consistency. By combining semantic search, keyword retrieval, and LSP symbol graphs, Atlas provides a comprehensive approach to navigate complex Solidity codebases, ensuring you find the exact file and symbol responsible for any observed contract behavior.

How Atlas Locates Solidity Behavior in a Foundry Project

Atlas employs a three-pronged strategy to locate Solidity behavior within a Foundry project, ensuring comprehensive coverage even when your search terms don't directly match code. This approach, refined by 2026, fuses semantic understanding, exact text matching, and symbol graph navigation to identify the precise implementation of a contract's function or modifier.

When a Solidity developer needs to find the code behind a specific contract behavior, Atlas initiates a multi-faceted search. First, `atlas codebase_search` uses hybrid semantic and keyword retrieval, powered by local Ollama embeddings, to understand the intent behind your description. This tool indexes Solidity code by AST declarations using tree-sitter, allowing it to return relevant candidate declarations from files like `src/MyContract.sol` even if your natural language query doesn't contain exact keywords. Second, `atlas grep` confirms these candidates or finds exact text matches using real regex patterns, with support for include and path filters, running through ripgrep. This is crucial for Solidity, where specific function names or variable declarations might be unique. Finally, the `atlas lsp` tool provides access to the symbol graph, enabling operations like `findReferences` to see all callsites for a function or `workspaceSymbol` to jump directly to a declaration by name, ensuring the exact symbol is identified.

Concrete Solidity Commands and File Paths for Code Discovery

Identifying Solidity code involves interacting with specific files and commands within a Foundry project, a workflow Atlas streamlines in 2026. Atlas understands the structure of a typical Foundry project, including `src/` for contracts, `test/` for tests, and `foundry.toml` for configuration, making navigation intuitive and precise.

To locate a behavior, a Solidity developer starts by describing it to Atlas. For instance, to find where a token transfer mechanism is implemented, you might use `atlas codebase_search "how does the ERC20 token transfer function work?"`. Atlas will then suggest candidate Solidity files, such as `src/Token.sol` or `src/ERC20.sol`. Once a promising file is identified, `atlas read src/Token.sol` allows you to inspect its contents. If a specific function name, like `_transfer`, is known or suspected, `atlas grep "_transfer\("` can quickly locate all occurrences. For deeper analysis, `atlas lsp findReferences "_transfer"` will show every callsite of that function across your project, including within `test/MyContract.t.sol` files. Atlas also recognizes libraries installed by `forge soldeer install`, ensuring that even external dependencies are searchable and navigable, providing a complete view of the Solidity codebase.

Ensuring Safety and Review in Solidity Code Changes with Atlas

Atlas prioritizes safety and developer review in Solidity projects, a critical aspect given the high stakes of smart contract development in 2026. Every proposed code change, from adding a reentrancy guard to converting a `require` string, undergoes a rigorous, permission-gated approval process, including gas cost analysis.

When Atlas proposes an edit to a Solidity contract, such as modifying `src/MyContract.sol` to add a reentrancy guard or converting a `require` string to a custom error to cut deploy size, it operates with a strong emphasis on developer oversight. Atlas first drafts a plan in a read-only plan agent and asks for approval before switching to a build agent. Every tool call is permission-gated against allow, ask, and deny rules. Before writing any changes, Atlas computes a unified diff for every file edit and surfaces it for approval. For Solidity, this includes running `forge snapshot` to show the gas delta of the proposed changes, providing concrete metrics for review. After approval, Atlas can even run `forge fmt` on the diff to ensure formatting consistency and stage and create commits on your behalf, integrating direct into your existing Git workflow and ensuring every change is transparent and auditable.

Debugging and Tracing Solidity Execution Paths with Atlas LSP

In 2026, Atlas's `lsp` tool is indispensable for debugging and tracing Solidity execution paths, allowing developers to understand complex interactions between contracts. By leveraging the Language Server Protocol, Atlas can map a behavior back to its originating declaration and all its call sites, even across multiple files.

When a Solidity behavior is observed, and its implementation needs to be traced, the `atlas lsp` tool becomes a powerful ally. After identifying a candidate function or modifier using `codebase_search` or `grep`, a developer can use `atlas lsp workspaceSymbol "MyFunction"` to jump directly to the declaration of `MyFunction` within `src/MyContract.sol`. From there, `atlas lsp findReferences "MyFunction"` reveals every location where `MyFunction` is called, providing a complete call path. This is particularly useful in Solidity for understanding how state changes propagate or how a specific vulnerability might be triggered. Atlas can then summarize this call path back to the user with concrete file and line references, such as `src/MyContract.sol:123 -> src/AnotherContract.sol:456`, making it easy to follow the flow of execution and pinpoint the exact code responsible for a behavior.

Step by step

011. Initialize Atlas in your Foundry project by ensuring a `foundry.toml` and `src/` directory exist, allowing Atlas to index your Solidity contracts and `forge soldeer` installed libraries.
022. Describe the observed Solidity behavior to Atlas using `atlas codebase_search "how does the token burning mechanism work?"` to semantically retrieve candidate declarations from files like `src/Token.sol`.
033. Confirm potential code locations or find exact text matches with `atlas grep "burn\(address from, uint256 amount\)"` across your `src/` directory, leveraging ripgrep's regex capabilities.
044. Open and review the most promising Solidity file, for example, `src/MyToken.sol`, using `atlas read src/MyToken.sol` to inspect its contents directly in your terminal.
055. Use `atlas lsp workspaceSymbol "_burn"` to jump directly to the declaration of the `_burn` function, then `atlas lsp findReferences "_burn"` to see all its callsites within your project, including `test/MyToken.t.sol`.
066. If proposing a change, like adding a reentrancy guard, Atlas will draft a plan and ask for approval, then compute a unified diff and run `forge snapshot` to show the gas delta before writing to `src/MyContract.sol`.
077. Approve the changes, and Atlas can automatically run `forge fmt` on the modified Solidity files and stage the changes for a commit, ensuring code quality and auditability.

Frequently asked questions

How does Atlas handle Solidity dependencies installed by Soldeer?: Atlas fully integrates with Foundry projects, including libraries installed via `forge soldeer install`. Atlas builds its code index with these dependencies, allowing `codebase_search`, `grep`, and `lsp` tools to navigate and analyze code across your `src/` directory and all installed external contracts, providing a complete view of your Solidity codebase.
Can Atlas help me understand the gas cost impact of Solidity changes?: Yes, Atlas is designed with Solidity's unique requirements in mind. Before applying any proposed changes to your `src/` files, Atlas will run `forge snapshot` to compute and display the gas delta. This allows you to see the precise gas cost impact of the modifications, such as adding a reentrancy guard or converting a `require` string to a custom error, directly within your terminal for informed approval.
What specific Solidity files does Atlas index for search?: Atlas indexes all Solidity files within your Foundry project, primarily focusing on the `src/` directory for your contracts and any libraries installed by `forge soldeer`. It builds its code index using AST declarations, meaning it understands the structure of your contracts, storage layouts, modifiers, and functions, providing a more intelligent search than simple text matching.
How does Atlas ensure safety when modifying Solidity contracts?: Atlas employs a multi-layered safety approach for Solidity. It drafts plans in a read-only agent, asks for explicit permission before executing tools, and presents a unified diff for every file edit for your approval. Furthermore, for Solidity, it runs `forge snapshot` to show gas deltas and can apply `forge fmt` to maintain code style, ensuring transparency and control over all changes to your `src/` files.
Can Atlas help me write Solidity fuzz tests?: Yes, Atlas can assist in writing fuzz tests for your Solidity contracts. You can ask Atlas to write a fuzz test in your `test/` directory. After drafting the test, Atlas can run `forge test` behind a permission prompt, allowing you to verify the test's effectiveness and ensure your contract behaves as expected under various conditions, all within your Foundry environment.
How does Atlas's LSP tool benefit Solidity development?: Atlas's `lsp` tool is invaluable for Solidity developers. It allows you to use `workspaceSymbol` to jump directly to the declaration of any contract, function, or modifier by name, and `findReferences` to see every callsite. This is critical for understanding complex Solidity codebases, tracing execution flows, and refactoring, providing a symbol-aware navigation experience that goes beyond simple text search.

Try Atlas in your terminal

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

Install Atlas

Related guides

Locate Where a Behavior Is Implemented with Atlas in 2026

How to locate where a behavior is implemented with Atlas in 2026: codebase_search for meaning, grep for exact text, and the lsp tool for the symbol graph.

Review a Pull Request in Solidity with Atlas in 2026

Atlas helps Solidity developers in 2026 review pull requests by providing deep context, running `forge test`, and checking for vulnerabilities. Catch subtle bugs in your smart contracts and ensure robust code quality.

Diagnose a Hanging or Long-Running Command in Solidity with Atlas in 2026

Solidity developers in 2026 can use Atlas to diagnose whether a `forge test` or `forge soldeer install` command is genuinely slow or silently blocked on input, and get it unstuck.

Write Unit Tests for Untested Solidity Code with Atlas in 2026

Add robust unit tests to your Solidity contracts using Atlas. Leverage `forge test`, `soldeer`, and `forge fmt` to ensure code quality and security in 2026.

Trace a Runtime Bug from a Solidity Stack Trace with Atlas in 2026

Pinpoint and fix Solidity runtime bugs from production stack traces using Atlas. Leverage Foundry's `forge test` and `soldeer` for a secure, gas-efficient workflow.

Automate GitHub Issue and Pull Request Triage in Solidity with Atlas in 2026

Automate GitHub issue and pull request triage for Solidity projects using Atlas. Safely respond to PRs and issues in 2026, ensuring trusted users and proper context handling with Foundry.

Onboard to an Unfamiliar Solidity Codebase with Atlas in 2026

Solidity developers in 2026 can rapidly build a mental model of any unfamiliar codebase using Atlas. Leverage semantic search, AST indexing, and Foundry toolchain integration with forge test, soldeer, and forge fmt.

Document a module with a README in Solidity with Atlas in 2026

In 2026, Atlas helps Solidity developers generate accurate READMEs for smart contracts. It uses `forge test`, `soldeer`, and `forge fmt` to reflect current code behavior.

Browse this resource hub