How does Atlas understand my Laravel Eloquent models?

Atlas indexes your Laravel codebase using tree-sitter for AST declarations, allowing it to understand the structure of your Eloquent models, their relationships, and methods, even without explicit keyword matches. This deep understanding aids in precise semantic searches.

Can Atlas find code in my Laravel routes file?

Yes, Atlas's `codebase_search` and `grep` tools are fully capable of searching your Laravel route definitions in files like `routes/web.php` or `routes/api.php`, identifying specific route handlers, middleware, or controller actions linked to those routes.

Does Atlas support Laravel's `Pest` test runner?

Absolutely. Atlas can read your existing `Pest` tests and can even be asked to generate new ones, reviewing the diff before applying any changes to your `tests/Pest.php` or feature test files, ensuring your test suite remains robust.

How does Atlas handle large Laravel projects?

Atlas is designed for large codebases, using hybrid semantic and keyword retrieval fused by reciprocal rank fusion for efficient searching. It can also build its code index with local Ollama embeddings, keeping your Laravel code off third-party servers and ensuring privacy.

What if Atlas suggests a wrong file in my Laravel project?

If Atlas's `read` tool is given a wrong path, it fails loudly with "File not found" and a "Did you mean" list, preventing you from wasting time on non-existent files. You can then refine your search or `grep` query based on the suggestions.

Can Atlas help me understand a complex Laravel service provider?

Yes, you can use `codebase_search` to describe the service provider's function, then `read` the file, and finally use `lsp findReferences` on key methods within the provider to trace its interactions and understand its role in the Laravel application lifecycle and dependency injection.

Is Atlas compatible with my existing Laravel development environment?

Atlas is terminal-native, rendered with SolidJS through the OpenTUI renderer, and integrates with your local `git` setup. It works alongside your existing Laravel toolchain, including `Composer` for package management and `Laravel Pint` for formatting, without requiring significant changes to your environment.

Locate Laravel Behavior Implementations with Atlas in 2026

In 2026, Laravel developers leverage Atlas to pinpoint where a behavior is implemented, even when only knowing what the software does. Atlas combines semantic search, `grep` for exact text, and the `lsp` tool for symbol graph analysis, integrating direct with your existing `Composer` and `Pest` workflows to provide precise file and symbol locations within your Laravel application.

How does Atlas locate Laravel code by behavior?

Atlas helps Laravel developers in 2026 locate code by describing its behavior, not just its name. It uses a hybrid semantic and keyword retrieval system, indexing your Laravel codebase with tree-sitter for precise AST declarations, ensuring it finds relevant Eloquent models or controller methods even if your query doesn't contain 100% matching keywords.

When you need to find the code responsible for a specific action in your Laravel application, but you don't know the exact class or method name, Atlas's `codebase_search` tool is your starting point. Instead of guessing keywords, you describe the behavior in natural language, such as "find the code that processes user login and sets a session." Atlas then searches its semantic index, which is built locally using Ollama embeddings to keep your Laravel code off third-party servers. This index understands the meaning and context of your code, allowing it to return candidate declarations from files like `app/Http/Controllers/Auth/LoginController.php` or `app/Models/User.php`, even if your description doesn't perfectly match the source code's terminology. This approach is particularly effective for complex Laravel applications where behaviors might be spread across multiple components, from middleware to event listeners.

How to confirm Laravel code with Atlas's grep and read tools?

After Atlas's semantic search suggests candidate Laravel files, you can confirm the exact code with the `grep` tool, which leverages `ripgrep` for fast, precise regex matching. This allows you to filter results by specific Laravel file patterns like `app/Http/Controllers/*.php` or `database/migrations/*`, ensuring you're looking at the right 1-2 files.

Once `codebase_search` provides a list of potential Laravel files or symbols, you can use Atlas's `grep` tool to perform a targeted, exact text search. This is crucial for confirming specific strings, variable names, or method calls within the suggested files. For instance, if `codebase_search` points to a controller, you might then run `atlas grep "Auth::attempt" --include="app/Http/Controllers/*.php"` to find the exact line where authentication is attempted. The `grep` tool supports full regex patterns and path filters, making it highly flexible for navigating your Laravel project structure. After confirming a promising file, the `read` tool allows you to open and view its contents directly within your terminal. If you accidentally provide a wrong path, Atlas will loudly report "File not found" and offer a "Did you mean" list, preventing wasted time and guiding you to the correct Laravel file.

How to trace Laravel call paths with Atlas's LSP tool?

Once you've identified a potential Laravel code segment, Atlas's `lsp` tool becomes invaluable for understanding its full context. It connects to Model Context Protocol servers, exposing operations like `findReferences` to show every callsite of a method or `workspaceSymbol` to jump to a declaration by name, providing a 360-degree view of the code's interactions within your application.

Understanding how a specific piece of Laravel code is used throughout your application is critical for debugging or making changes. Atlas's `lsp` tool provides deep insights into the symbol graph of your codebase. After using `read` to view a file like `app/Services/OrderProcessor.php`, you can then use `atlas lsp findReferences app/Services/OrderProcessor.php processOrder` to see every location where the `processOrder` method is called. This helps you trace the flow of execution from a Laravel route or an Artisan command down to the specific service. Conversely, if you know a method's name but not its location, `atlas lsp workspaceSymbol processOrder` can directly jump you to its declaration. This powerful integration allows you to navigate complex Laravel architectures, understanding dependencies and call chains with precision, whether it's an Eloquent model method, a controller action, or a custom helper function.

How does Atlas ensure safe code changes in Laravel?

Atlas prioritizes safety when working with your Laravel codebase, ensuring every proposed change is thoroughly reviewed. Before any tool call runs, it's permission-gated against allow, ask, and deny rules. Furthermore, Atlas computes a unified diff for every file edit and surfaces it for approval, allowing you to review up to 10 lines of context before writing anything.

Even when your primary goal is just to locate code, understanding Atlas's safety mechanisms is important, as it can also be used to modify your Laravel project. Every action Atlas takes, especially those that might alter files, is permission-gated. This means you have explicit control over what Atlas can do, with options to allow, ask for confirmation, or deny specific tool calls. When Atlas drafts a plan to make an edit, it first operates in a read-only plan agent, presenting its strategy for your approval before switching to a build agent. Crucially, for any file modification, Atlas computes a unified diff, similar to what you'd see with `git diff`. This diff is presented to you for approval, showing exactly what lines will be added, removed, or changed in your Laravel files, such as `app/Http/Controllers/UserController.php` or `database/migrations/2026_01_01_create_users_table.php`. This granular control ensures that you always have the final say over any changes, preventing unintended modifications to your Laravel application.

How to set up Atlas for a Laravel project?

Integrating Atlas into your Laravel development workflow is straightforward, typically taking less than 5 minutes. Simply run Atlas within your Laravel application's root directory, ensuring the `artisan` file is present. Atlas will then automatically read your Eloquent models, routes, and database migrations, building a comprehensive index of your project's structure.

Getting Atlas ready to help you locate behavior in your Laravel project is a quick process. First, ensure you are in the root directory of your Laravel application, where the `artisan` command-line tool resides. Simply type `atlas` in your terminal to launch the agent. Atlas will automatically detect the Laravel environment and begin indexing your codebase. This indexing process leverages tree-sitter to parse your code by AST declarations, providing a much richer understanding than simple line-based indexing. It will read your `app/Models/*.php` files to understand your Eloquent models, scan `routes/*.php` for route definitions, and analyze `database/migrations/*.php` to grasp your database schema. This initial setup allows Atlas to build a robust semantic index, enabling it to effectively use `codebase_search`, `grep`, and `lsp` to help you pinpoint any behavior within your Laravel application, whether it's a complex service or a simple controller action.

Step by step

011: Start Atlas in your Laravel project's root directory: `atlas` (ensure the `artisan` file is present).
022: Describe the behavior you want to locate using `codebase_search`: `atlas codebase_search "find the code that handles user registration and sends a welcome email"`.
033: Review the candidate files returned by Atlas, then refine your search with `grep` for specific text patterns or file types: `atlas grep "UserRegisteredEvent" --include="app/Events/*.php"`.
044: Open the most promising Laravel file with the `read` tool: `atlas read app/Http/Controllers/Auth/RegisterController.php`.
055: Use the `lsp` tool's `findReferences` operation to see all callsites of a method within the file: `atlas lsp findReferences app/Http/Controllers/Auth/RegisterController.php register`.
066: Alternatively, use `lsp workspaceSymbol` to jump directly to a declaration by name if you know the symbol: `atlas lsp workspaceSymbol handleUserRegistration`.
077: Summarize the call path and implementation details back to yourself with concrete file and line references: `atlas summarize "Explain how the register method in RegisterController interacts with the User model and any associated events, referencing specific files and line numbers." --format=markdown`.
088: If you need to add a `Pest` test or modify code, Atlas will present a unified diff for your approval before writing any changes to your Laravel project.

Frequently asked questions

How does Atlas understand my Laravel Eloquent models?: Atlas indexes your Laravel codebase using tree-sitter for AST declarations, allowing it to understand the structure of your Eloquent models, their relationships, and methods, even without explicit keyword matches. This deep understanding aids in precise semantic searches.
Can Atlas find code in my Laravel routes file?: Yes, Atlas's `codebase_search` and `grep` tools are fully capable of searching your Laravel route definitions in files like `routes/web.php` or `routes/api.php`, identifying specific route handlers, middleware, or controller actions linked to those routes.
Does Atlas support Laravel's `Pest` test runner?: Absolutely. Atlas can read your existing `Pest` tests and can even be asked to generate new ones, reviewing the diff before applying any changes to your `tests/Pest.php` or feature test files, ensuring your test suite remains robust.
How does Atlas handle large Laravel projects?: Atlas is designed for large codebases, using hybrid semantic and keyword retrieval fused by reciprocal rank fusion for efficient searching. It can also build its code index with local Ollama embeddings, keeping your Laravel code off third-party servers and ensuring privacy.
What if Atlas suggests a wrong file in my Laravel project?: If Atlas's `read` tool is given a wrong path, it fails loudly with "File not found" and a "Did you mean" list, preventing you from wasting time on non-existent files. You can then refine your search or `grep` query based on the suggestions.
Can Atlas help me understand a complex Laravel service provider?: Yes, you can use `codebase_search` to describe the service provider's function, then `read` the file, and finally use `lsp findReferences` on key methods within the provider to trace its interactions and understand its role in the Laravel application lifecycle and dependency injection.
Is Atlas compatible with my existing Laravel development environment?: Atlas is terminal-native, rendered with SolidJS through the OpenTUI renderer, and integrates with your local `git` setup. It works alongside your existing Laravel toolchain, including `Composer` for package management and `Laravel Pint` for formatting, without requiring significant changes to your environment.

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.

Atlas for Laravel in 2026

Atlas is a terminal-native AI coding agent for Laravel in 2026. Run it in a Laravel app with an artisan file, add a controller or Pest test, and review the diff.

Onboard to an Unfamiliar Laravel Codebase with Atlas in 2026

Quickly build a working mental model of any Laravel project in 2026 using Atlas. Leverage semantic search, explore tools, and review changes to understand Eloquent models, routes, and more.

Document a Module with a README in Laravel with Atlas in 2026

In 2026, Laravel developers use Atlas to generate accurate READMEs for modules, ensuring documentation reflects current code. Atlas leverages Pest and Composer to verify code samples and integrates with Laravel Pint for

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

Catch your own mistakes in uncommitted Laravel diffs before CI or review. Atlas helps Laravel developers in 2026 self-review code changes, run Pest tests, and apply Laravel Pint formatting.

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

Streamline GitHub issue and pull request triage for your Laravel projects in 2026 using Atlas. Automate responses safely, ensuring only trusted users trigger actions within your familiar Laravel toolchain.

Audit a Laravel Repository with Parallel Subagents in 2026

Sweep your Laravel application for code issues in 2026 using Atlas's parallel subagents. Efficiently audit Eloquent models, routes, and tests without blowing your context window.

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

Pinpoint and fix Laravel runtime bugs directly from production stack traces using Atlas, the terminal-native AI coding agent. Leverage Composer, Pest, and Laravel Pint for a streamlined workflow.

Browse this resource hub