How does Atlas handle GraalVM-specific configurations like `reflect-config.json`?

Atlas is designed to understand GraalVM's unique requirements. It can read your reachability metadata under `META-INF/native-image` and identify reflective call sites. If a class only fails in the native binary, Atlas can add the missing `reflect-config.json` entry, or run the tracing agent, diff the generated metadata, and commit only the entries your code actually needs, all with your permission.

Can Atlas help me find code related to `native-image` build failures?

Yes, Atlas excels at this. You can describe the failure behavior, and Atlas will use `codebase_search` to find relevant code. It can then use `grep` to look for specific `native-image` flags in your `pom.xml` or `lsp` to trace calls related to problematic classes, helping you pinpoint the source of the build failure.

What if my GraalVM project uses a custom Maven profile for native builds?

Atlas is configured to work with standard GraalVM toolchains. When you instruct Atlas to run tests, it will use the actual command `mvn -Pnative test`, respecting your project's `pom.xml` and any custom profiles defined for native-image builds. This ensures Atlas operates within your established build environment.

How does Atlas ensure my GraalVM code isn't sent to external servers?

Atlas builds its code index with local Ollama embeddings. This means your GraalVM source code and its semantic representations remain entirely on your local machine, never leaving your development environment. This commitment to local processing ensures the privacy and security of your proprietary code.

Can Atlas help me understand the impact of a change in a GraalVM library?

Absolutely. Once you identify a specific symbol or class in a GraalVM library, Atlas's `lsp` tool can perform a `findReferences` operation across your entire workspace. This allows you to see every callsite within your project that uses that library component, helping you assess the potential impact of any changes or updates.

How does Atlas handle code formatting in GraalVM projects?

Atlas integrates with your existing GraalVM development practices. After making any code modifications, Atlas can apply your project's formatter, `Spotless`, to the diff. This ensures that any changes Atlas introduces adhere to your team's coding standards, maintaining code consistency and quality.

Locate where a behavior is implemented in GraalVM with Atlas in 2026

Atlas helps GraalVM developers in 2026 pinpoint where a specific behavior is implemented, even when only the functional outcome is known, not the code's name. It achieves this by combining semantic code search, precise text matching with `grep`, and symbol graph navigation via the `lsp` tool, all while respecting your project's `pom.xml` and `mvn -Pnative test` workflows.

How Atlas finds GraalVM behavior implementations with semantic search

Atlas begins its search for GraalVM behavior implementations by leveraging its `codebase_search` tool, which uses a hybrid semantic and keyword retrieval system. This approach allows Atlas to identify relevant code declarations even if your query uses different terminology than the source code itself, providing a powerful starting point in 2026.

When you describe a behavior in natural language, Atlas's `codebase_search` tool queries its AST-based index. Unlike simple text searches, this index understands the structure and meaning of your GraalVM codebase, built with local Ollama embeddings to keep your proprietary code secure. For instance, if you describe a 'runtime reflection issue in native-image builds,' Atlas can semantically link this to code that handles `reflect-config.json` entries or dynamic proxy declarations, even if your description doesn't contain those exact keywords. This initial semantic pass provides a broad set of candidate declarations, significantly narrowing down the search space before more precise tools are engaged.

Confirming GraalVM code locations with precise grep and file access

After an initial semantic search, Atlas confirms potential GraalVM code locations using its `grep` tool, which runs `ripgrep` with real regex patterns and path filters. This step ensures 100% text match accuracy, allowing you to validate semantic findings against the actual source code, especially critical for `native-image` specific configurations.

Once `codebase_search` returns candidate declarations, Atlas uses its `grep` tool to confirm the presence of specific keywords, patterns, or file types. For a GraalVM project, this might involve searching for specific annotations, `native-image` build flags within `pom.xml`, or entries in `META-INF/native-image` metadata files. You can provide a real regex, along with `include` and `path` filters, to narrow the search to relevant Java source files or configuration files. If a candidate file looks promising, Atlas can then use the `read` tool to open it. A wrong guess fails loudly with 'File not found' and a 'Did you mean' list, preventing wasted time on incorrect paths and ensuring you always work with existing GraalVM project files.

Navigating GraalVM symbol graphs with the LSP tool

To fully understand a GraalVM behavior's implementation, Atlas employs its `lsp` tool, which provides deep insights into the symbol graph. This allows developers to jump directly to declarations, find all references to a specific method or class, and trace call paths, crucial for debugging complex `native-image` runtime issues in 2026.

The `lsp` tool is indispensable for GraalVM developers needing to understand code relationships. Once you've identified a promising class or method using `read`, you can ask Atlas to use `lsp`'s `findReferences` operation to see every callsite of that symbol across your project. This is particularly useful for understanding how a specific piece of logic, perhaps related to `reflect-config.json` generation or resource loading, is invoked throughout the codebase. Conversely, the `workspaceSymbol` operation allows you to jump directly to a declaration by name, providing immediate context. Atlas can then summarize the entire call path back to you, complete with concrete file and line references, helping you quickly grasp the flow of execution within your GraalVM application.

Ensuring safety and review in GraalVM code changes with Atlas

Atlas prioritizes safety and developer control throughout the GraalVM code location and modification process. Every Atlas tool call is permission-gated, and all proposed changes are presented as unified diffs for approval, ensuring you maintain full oversight of your `pom.xml` and source code in 2026.

Before Atlas executes any action, such as running `mvn -Pnative test` or applying `Spotless` to a diff, it seeks your explicit permission. This is managed through allow, ask, and deny rules. Atlas first drafts a plan in a read-only plan agent, detailing its intended steps, and asks for your approval before switching to a build agent. When Atlas proposes a code modification, for example, adding a missing `reflect-config.json` entry, it computes a unified diff for every file edit. This diff is surfaced for your approval, allowing you to review the exact changes before they are written to your GraalVM project. Atlas also snapshots file changes as git patches, enabling easy diffing and rollback of any edits, providing a robust safety net for your development workflow.

Step by step

01Describe the GraalVM behavior to Atlas using `codebase_search`, for example: 'Find where dynamic proxy creation is handled in native-image builds.'
02Review the semantic index's candidate declarations, which Atlas returns even if your words do not appear in the GraalVM source.
03Confirm the best candidate with Atlas's `grep` tool, providing a real regex and path filters like `*.java` or `META-INF/native-image/**`.
04Open the most promising GraalVM source file with Atlas's `read` tool; Atlas will loudly report 'File not found' if the path is incorrect.
05Use Atlas's `lsp` tool with `findReferences` to see every callsite of a key method or class in your GraalVM project.
06Alternatively, use `lsp`'s `workspaceSymbol` to jump directly to a GraalVM declaration by its name.
07Ask Atlas to summarize the call path back to you, including concrete GraalVM file and line references.
08If modifications are needed, let Atlas run `mvn -Pnative test` behind a permission prompt, then apply `Spotless` to the diff before committing.

Frequently asked questions

How does Atlas handle GraalVM-specific configurations like `reflect-config.json`?: Atlas is designed to understand GraalVM's unique requirements. It can read your reachability metadata under `META-INF/native-image` and identify reflective call sites. If a class only fails in the native binary, Atlas can add the missing `reflect-config.json` entry, or run the tracing agent, diff the generated metadata, and commit only the entries your code actually needs, all with your permission.
Can Atlas help me find code related to `native-image` build failures?: Yes, Atlas excels at this. You can describe the failure behavior, and Atlas will use `codebase_search` to find relevant code. It can then use `grep` to look for specific `native-image` flags in your `pom.xml` or `lsp` to trace calls related to problematic classes, helping you pinpoint the source of the build failure.
What if my GraalVM project uses a custom Maven profile for native builds?: Atlas is configured to work with standard GraalVM toolchains. When you instruct Atlas to run tests, it will use the actual command `mvn -Pnative test`, respecting your project's `pom.xml` and any custom profiles defined for native-image builds. This ensures Atlas operates within your established build environment.
How does Atlas ensure my GraalVM code isn't sent to external servers?: Atlas builds its code index with local Ollama embeddings. This means your GraalVM source code and its semantic representations remain entirely on your local machine, never leaving your development environment. This commitment to local processing ensures the privacy and security of your proprietary code.
Can Atlas help me understand the impact of a change in a GraalVM library?: Absolutely. Once you identify a specific symbol or class in a GraalVM library, Atlas's `lsp` tool can perform a `findReferences` operation across your entire workspace. This allows you to see every callsite within your project that uses that library component, helping you assess the potential impact of any changes or updates.
How does Atlas handle code formatting in GraalVM projects?: Atlas integrates with your existing GraalVM development practices. After making any code modifications, Atlas can apply your project's formatter, `Spotless`, to the diff. This ensures that any changes Atlas introduces adhere to your team's coding standards, maintaining code consistency and quality.

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.

Automate GitHub issue and pull request triage in GraalVM with Atlas in 2026

In 2026, GraalVM developers can automate GitHub issue and pull request triage using Atlas. Configure Atlas in a GitHub workflow to safely respond to events, ensuring only trusted users trigger actions and maintaining

Rename a symbol across the repo in GraalVM with Atlas in 2026

Streamline symbol renames in GraalVM projects using Atlas. Leverage LSP for precise refactoring, catch all occurrences with grep, and ensure safety with diff approvals for native-image builds.

Audit a GraalVM Repo with Parallel Subagents in 2026

Sweep your GraalVM repository for specific problems without blowing your context window. Atlas launches parallel subagents to audit native-image builds, reflection, and resource configurations.

Migrate a Deprecated API Across Every Callsite in GraalVM with Atlas in 2026

Streamline deprecated API migrations in GraalVM projects using Atlas. Discover how Atlas enumerates all callsites, applies context-aware patches, and validates changes with 'mvn -Pnative test' for robust native-image

Refactor a legacy GraalVM module with Atlas in 2026

Streamline GraalVM module refactoring in 2026 with Atlas. Safely restructure code, manage native-image metadata, and validate changes using mvn -Pnative test and Spotless.

Run Atlas Headless in CI for GraalVM Projects in 2026

Streamline GraalVM native-image builds in CI with Atlas. Run Atlas headless, get machine-readable JSON output, and automate reflect-config.json updates using Maven and Spotless.

Review a Pull Request in GraalVM with Atlas in 2026

In 2026, GraalVM developers use Atlas to review pull requests, catching subtle bugs by examining full file context and checking native-image configurations, ensuring robust native binaries.

Browse this resource hub