Can Atlas audit my Laravel Eloquent models for N+1 queries?

Yes, Atlas can launch an `explore` subagent to sweep your `app/Models` directory, identifying potential N+1 query patterns by analyzing Eloquent relationships and usage. It can `grep` for common patterns like `->load()` or `->with()` to help pinpoint areas for optimization.

How does Atlas handle large Laravel projects with many files?

Atlas addresses large Laravel projects by fanning out audit tasks to parallel subagents. Each subagent processes a specific slice, like `app/Http/Controllers` or a particular `Composer` package, preventing the main session's context window from being overwhelmed and ensuring efficient processing.

Is it safe to let Atlas modify my Laravel codebase during an audit?

For audits, Atlas recommends the `explore` subagent, which is read-only by default. If modifications are needed, the `general` subagent can be used, but every edit generates a unified diff for your approval before writing to your Laravel files, providing full control and safety.

Can Atlas run `Pest` tests as part of a Laravel audit?

Yes, a `general` subagent can be configured to run `Pest` tests using the `php artisan pest` command within its session. This allows it to report on test failures related to specific code changes or issues found during an audit, ensuring code integrity in your Laravel project.

How does Atlas know about my Laravel routes and migrations?

Atlas builds its code index using AST declarations via tree-sitter, allowing it to understand the structure of your Laravel routes in `routes/web.php` and `routes/api.php`, as well as your database migrations in `database/migrations`. This provides a deep, structural understanding of your Laravel application.

What if an Atlas subagent fails during a Laravel audit?

If an Atlas subagent fails during a Laravel audit, the `task` tool surfaces the child's error text verbatim. This allows you to diagnose issues, such as a syntax error in a `config/app.php` file, a problem with a `Composer` dependency, or an unexpected output from a `php artisan` command.

Can Atlas help me refactor old Laravel code after an audit?

While this page focuses on auditing, Atlas's `general` subagents can be used for refactoring. They can propose changes, generate unified diffs for your approval, and even run `Laravel Pint` to ensure code style consistency after refactoring old Laravel code, making the process efficient and controlled.

Audit a Laravel Repository with Parallel Subagents in 2026

Atlas empowers Laravel developers in 2026 to sweep an entire repository for a class of problems without blowing the main session's context window by fanning out work to parallel subagents, allowing you to audit Eloquent models, routes, and even `Pest` tests concurrently.

How do parallel subagents audit Laravel codebases?

Atlas in 2026 leverages parallel subagents to audit Laravel codebases by splitting the repository into independent slices, such as by directory or package, and assigning each slice to a dedicated subagent. This approach prevents the main session's context window from being overwhelmed, ensuring efficient scanning of your `app/Models` and `routes`.

When auditing a Laravel application, Atlas's `task` tool launches subagents in their own isolated sessions. This means their file dumps and intermediate thoughts never enter your main context window; only their final conclusions are returned. For a read-only sweep, the `explore` subagent type is ideal, as it is deny-by-default, preventing any accidental modifications to your Laravel project. You can define audit slices by common Laravel directory structures, for example, dedicating one subagent to `app/Models` for Eloquent-related issues, another to `app/Http/Controllers` for controller logic, and a third to `tests/Feature` for `Pest` or PHPUnit test coverage. By issuing multiple `task` calls together, these subagents run concurrently, drastically speeding up the audit process across your entire Laravel codebase.

What Atlas commands audit Laravel files like `app/Models`?

To audit specific Laravel files, Atlas employs tools like `grep` and `glob` to target directories such as `app/Models` or `database/migrations` within a subagent's read-only session. This ensures precise scanning without modifying the codebase, allowing a Laravel developer to pinpoint issues in 2026.

Within an Atlas subagent session, you can use familiar tools to target specific Laravel files and patterns. The `glob` tool can identify all PHP files within a directory, for instance, `glob('app/Models/*.php')` to list all Eloquent models. Once files are identified, the `grep` tool can search for specific patterns or anti-patterns within those files, such as deprecated helper functions or specific database query patterns in your `app/Models` or `app/Http/Controllers`. For example, a subagent could `grep` for specific method calls across `app/Services/**/*.php` files. Atlas also understands your `composer.json` dependencies and can be instructed to analyze specific packages installed via `Composer`. This granular control, combined with Atlas's AST-based indexing, allows for highly targeted and context-aware audits of your Laravel application's structure and code.

How does Atlas ensure safe, read-only Laravel code audits?

Atlas ensures safe, read-only Laravel code audits through its `explore` subagent type, which is deny-by-default, preventing any modifications to your `app/Http/Controllers` or `config` files. Every Atlas tool call is permission-gated, requiring explicit approval before execution in 2026.

The `explore` subagent type is specifically designed for read-only operations, making it the ideal choice for auditing a Laravel repository. This subagent operates with a deny-by-default policy, meaning it cannot execute commands that would alter your codebase, such as writing to `app/Providers/AppServiceProvider.php` or modifying `database/migrations`. Furthermore, Atlas implements robust safety mechanisms: every tool call, even within a subagent, is permission-gated against allow, ask, and deny rules. Before any potential change, Atlas drafts a plan in a read-only plan agent and asks for your approval. If a `general` subagent is used and proposes an edit, Atlas computes a unified diff for every file edit and surfaces it for your approval before writing to any Laravel file, providing complete transparency and control over your project's integrity.

How does Atlas integrate with Laravel's `Pest` and `Composer`?

Atlas integrates direct with Laravel's core toolchain, allowing subagents to understand and interact with `Composer` dependencies, `Pest` test files, and `Laravel Pint` configurations. This deep integration ensures audits are contextually aware of your project's setup in 2026, from `artisan` commands to `phpunit.xml`.

Atlas is built to be terminal-native and understands the context of your development environment, including your Laravel project. It can read your `composer.json` file to understand project dependencies and scripts, and it recognizes the presence of the `artisan` file, indicating a Laravel application. When auditing, Atlas can be instructed to analyze `Pest` test files located in `tests/Feature` or `tests/Unit`, understanding their structure through its AST indexing. While `explore` subagents are read-only, a `general` subagent could be tasked with running `php artisan pest` to validate test suites or even apply formatting with `php artisan pint` to ensure code style consistency across your Laravel project. This deep integration means Atlas doesn't just see lines of code; it understands the roles of your Eloquent models, routes, and the conventions of your Laravel application.

Step by step

01Initialize Atlas in your Laravel project by running `atlas` in the root directory containing your `artisan` file, allowing it to index your models, routes, and migrations.
02Identify independent slices of your Laravel codebase for auditing, such as `app/Models`, `app/Http/Controllers`, `database/migrations`, or specific `Composer` packages.
03Launch parallel `explore` subagents for each slice using the `task` tool, ensuring read-only sweeps. For example: `task 'Audit app/Models for N+1 queries' subagent_type explore 'grep -r "->load(" app/Models'` and `task 'Audit routes for unused definitions' subagent_type explore 'grep -r "Route::get(" routes/web.php'`.
04Issue all `task` calls together to run concurrently, maximizing efficiency across your Laravel repository. Atlas will surface each subagent's final message, including any error text if a task fails.
05Collect the findings from each subagent's final message and merge them into a unified `todowrite` list in your main Atlas session, categorizing issues found in your Laravel code.
06Address the identified issues in your main session using the `edit` tool. For example, `edit app/Models/User.php` to fix an N+1 query, then run `php artisan pint` to format the changes and `php artisan pest` to verify tests.
07Review the unified diffs presented by Atlas for each `edit` operation, ensuring all changes to your Laravel files are approved before writing them to disk.
08Stage and create commits for the resolved issues directly through Atlas, leveraging its `git` integration to finalize your Laravel code audit.

Frequently asked questions

Can Atlas audit my Laravel Eloquent models for N+1 queries?: Yes, Atlas can launch an `explore` subagent to sweep your `app/Models` directory, identifying potential N+1 query patterns by analyzing Eloquent relationships and usage. It can `grep` for common patterns like `->load()` or `->with()` to help pinpoint areas for optimization.
How does Atlas handle large Laravel projects with many files?: Atlas addresses large Laravel projects by fanning out audit tasks to parallel subagents. Each subagent processes a specific slice, like `app/Http/Controllers` or a particular `Composer` package, preventing the main session's context window from being overwhelmed and ensuring efficient processing.
Is it safe to let Atlas modify my Laravel codebase during an audit?: For audits, Atlas recommends the `explore` subagent, which is read-only by default. If modifications are needed, the `general` subagent can be used, but every edit generates a unified diff for your approval before writing to your Laravel files, providing full control and safety.
Can Atlas run `Pest` tests as part of a Laravel audit?: Yes, a `general` subagent can be configured to run `Pest` tests using the `php artisan pest` command within its session. This allows it to report on test failures related to specific code changes or issues found during an audit, ensuring code integrity in your Laravel project.
How does Atlas know about my Laravel routes and migrations?: Atlas builds its code index using AST declarations via tree-sitter, allowing it to understand the structure of your Laravel routes in `routes/web.php` and `routes/api.php`, as well as your database migrations in `database/migrations`. This provides a deep, structural understanding of your Laravel application.
What if an Atlas subagent fails during a Laravel audit?: If an Atlas subagent fails during a Laravel audit, the `task` tool surfaces the child's error text verbatim. This allows you to diagnose issues, such as a syntax error in a `config/app.php` file, a problem with a `Composer` dependency, or an unexpected output from a `php artisan` command.
Can Atlas help me refactor old Laravel code after an audit?: While this page focuses on auditing, Atlas's `general` subagents can be used for refactoring. They can propose changes, generate unified diffs for your approval, and even run `Laravel Pint` to ensure code style consistency after refactoring old Laravel code, making the process efficient and controlled.

Try Atlas in your terminal

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

Install Atlas

Related guides

Audit a Repo with Parallel Subagents in Atlas (2026 Workflow)

How to audit a repo with parallel subagents in Atlas in 2026: the task tool launches explore subagents in their own sessions, so only conclusions return to your context.

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.

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.

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

Laravel developers in 2026 can use Atlas to diagnose hanging `artisan` commands, `Composer` installs, or `Pest` tests. Quickly identify if a script is blocked on input or genuinely slow, and get it unstuck.

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

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.

Review a Pull Request in Laravel with Atlas in 2026

In 2026, Atlas helps Laravel developers review pull requests by fetching diffs, reading full files, checking LSP references, and running Pest tests for comprehensive bug detection.

Locate Laravel Behavior Implementations with Atlas in 2026

In 2026, Laravel developers use Atlas to quickly locate behavior implementations, pinpointing exact files and symbols across Eloquent models, routes, and Artisan commands. Find code by describing its function.

Browse this resource hub