How does Atlas handle large OCaml projects with many `dune` files?

Atlas indexes OCaml code by AST declarations using tree-sitter, understanding each `dune` stanza and `.mli` signature. This allows it to build a comprehensive code index for large projects, which subagents can then query efficiently without loading the entire codebase into a single context window.

Can Atlas subagents run `dune runtest` on specific OCaml packages?

Yes, a `general` subagent can be instructed to run `dune runtest` within a specific `test/` directory or for a particular `dune` package. Atlas will prompt for permission before executing the command and read any compiler errors or test failures back into the plan for review.

How does Atlas ensure my OCaml code isn't sent to external servers during an audit?

Atlas can build its code index with local Ollama embeddings, keeping your OCaml source code entirely off third-party servers. This ensures that sensitive `.ml` and `.mli` files remain within your local environment during the auditing process.

What if an Atlas subagent proposes an incorrect change to an OCaml file?

Atlas computes a unified diff for every file edit, including changes to OCaml source files or `dune` configurations. This diff is surfaced for your approval before any changes are written. You can review, modify, or reject the proposed edits, maintaining full control over your OCaml codebase.

Can Atlas help enforce `ocamlformat` consistency across an OCaml repository?

Absolutely. After an Atlas subagent or the main agent makes modifications to OCaml files, you can instruct Atlas to run `ocamlformat` on the affected files. This ensures that all proposed changes adhere to your project's formatting standards before you approve the final diff, maintaining a clean and consistent OCaml codebase.

How do I split an OCaml repository for parallel subagent auditing?

You can split an OCaml repository by logical boundaries such as `dune` packages, top-level directories like `src/`, `lib/`, or `bin/`, or even by specific problem types. For example, one subagent could audit `src/parser/` for error handling, while another audits `lib/types/` for variant exhaustiveness.

Does Atlas understand OCaml module interfaces (`.mli` files)?

Yes, Atlas reads your `.mli` interface files as part of its code indexing process. This allows it to understand module signatures and types, which is crucial for tasks like ensuring variant exhaustiveness or adding an Alcotest case to a `test/dune` stanza based on exposed interfaces.

Audit an OCaml Repository with Parallel Subagents in Atlas, 2026

In 2026, OCaml developers can sweep an entire repository for a class of problems without blowing the main session's context window by leveraging Atlas's parallel subagents. Atlas integrates directly with the OCaml toolchain, understanding `dune` build rules, `opam` switches, and `.mli` interface files, allowing for targeted, concurrent analysis across your codebase.

How Atlas Parallel Subagents Audit OCaml Codebases

Atlas's parallel subagents offer a powerful method for auditing OCaml codebases in 2026, allowing developers to sweep an entire repository for specific issues without overwhelming the primary agent's context window. This approach ensures that large-scale OCaml projects, often structured with multiple `dune` stanzas, can be thoroughly examined.

Atlas addresses the challenge of large OCaml codebases by fanning out work to subagents. These subagents operate in their own isolated sessions, meaning their extensive file dumps and intermediate thoughts never enter the main session's context. Only their concise conclusions return to the primary agent. For an OCaml repository, this means you can assign different subagents to audit distinct `dune` packages or specific directories like `src/core` or `lib/utils`, ensuring each subagent focuses on a manageable slice. Atlas builds its code index using AST declarations via tree-sitter, providing a precise understanding of OCaml syntax and structure, rather than relying on blind line windows. This allows subagents to perform highly targeted searches and analyses within their assigned OCaml code segments.

Splitting OCaml Code for Concurrent Subagent Audits

To effectively audit an OCaml repository, Atlas recommends splitting the codebase into independent slices, often aligning with `dune` project structure or logical directories. This strategy, crucial for 2026 development practices, prevents subagents from overlapping and maximizes the efficiency of parallel execution across your OCaml project.

When auditing an OCaml repository, the first step is to divide the work into distinct, non-overlapping slices. For instance, you might assign one subagent to examine the `bin/` directory for CLI argument parsing issues, another to `lib/data_structures` for type safety concerns, and a third to `test/` for missing Alcotest cases. Atlas's `task` tool is used to launch these subagents concurrently. Each task can be configured with `subagent_type explore` for read-only sweeps, ideal for initial audits where no changes should occur, or `subagent_type general` if the subagent needs to interact with the OCaml toolchain, such as running `dune runtest` or invoking `ocamlformat` on a specific file. This granular control ensures that each subagent operates efficiently on its designated OCaml code segment.

Read-Only Exploration vs. General Subagents for OCaml

Atlas offers two primary subagent types for OCaml audits: `explore` for read-only sweeps and `general` for interactive tasks, providing flexibility for various scenarios in 2026. The `explore` subagent is deny-by-default and read-only, making it the ideal choice for an initial audit where no modifications to `.ml` or `.mli` files should occur.

For an OCaml repository audit, selecting the correct subagent type is paramount. The `explore` subagent is designed for read-only operations. It can search OCaml code with hybrid semantic and keyword retrieval, index code by AST declarations, and build its code index with local Ollama embeddings, keeping your OCaml source off third-party servers. This is perfect for identifying a class of problems, like finding all instances of a deprecated module in `src/legacy_api.ml` or checking for specific pattern matching issues across `lib/`. If the audit requires interaction with the OCaml toolchain, such as running `dune runtest` after a speculative fix or applying `ocamlformat` to a section of code, the `general` subagent is necessary. Every Atlas tool call, including those that might modify OCaml files or run `opam` commands, is permission-gated against allow, ask, and deny rules, ensuring developer control.

Ensuring Safety and Review in OCaml Code Audits with Atlas

Atlas incorporates robust safety and review mechanisms into its OCaml auditing workflow, ensuring that any proposed changes to `.ml` or `dune` files are thoroughly vetted. In 2026, developers maintain full control over modifications, with Atlas providing a unified diff for every file edit before approval.

Safety is a core tenet of Atlas's design, especially when dealing with an OCaml codebase. Before any subagent, even a `general` type, can make a change to an OCaml source file or a `dune` configuration, Atlas drafts a plan in a read-only plan agent and asks for approval. If the plan involves modifying an OCaml file, Atlas computes a unified diff for every proposed edit and surfaces it for your approval. This allows you to review changes to `my_module.ml`, `my_interface.mli`, or even `dune-project` files before they are written to disk. Atlas also snapshots file changes as git patches, so edits can be diffed and rolled back if necessary. This meticulous review process, combined with permission-gated tool calls, ensures that your OCaml codebase remains stable and under your direct control throughout the audit and remediation phases.

Integrating OCaml Toolchain with Atlas for Audits

Atlas direct integrates with the OCaml toolchain, allowing subagents to leverage `dune runtest`, `opam`, and `ocamlformat` directly within their audit tasks. This deep integration, a key feature in 2026, ensures that OCaml-specific checks and fixes are performed using the tools OCaml developers already trust.

Atlas is designed to work within your existing OCaml development environment. When Atlas runs in a workspace with a `dune-project` at the root, it reads each `dune` stanza, your `.mli` signatures, and the packages pinned in your `opam` switch. This contextual awareness is crucial for effective auditing. For example, a subagent tasked with finding potential runtime errors might be instructed to run `dune runtest` within a specific `test/` directory and report any failures. If the audit involves code style, Atlas can be instructed to finish with `ocamlformat` on any modified `.ml` files, ensuring the diff is style-clean before you approve it. Atlas connects to Model Context Protocol servers, exposing these OCaml-specific tools to the agent, making it a powerful ally for maintaining high-quality OCaml code.

Step by step

01Initialize Atlas in your OCaml project root, ensuring a `dune-project` file is present for Atlas to index your `dune` stanzas and `opam` switch.
02Identify independent slices of your OCaml codebase for auditing, such as specific `dune` packages (e.g., `src/my_library`) or logical directories (e.g., `bin/cli`).
03Launch concurrent read-only audit tasks for each slice using `task subagent_type explore --name "Audit src/core" --prompt "Find all deprecated functions in src/core/"` to sweep for problems without making changes.
04For slices requiring interaction, launch `task subagent_type general --name "Fix test/utils" --prompt "Add Alcotest cases to test/utils/test_module.ml and run dune runtest"` to allow subagents to execute OCaml commands.
05Collect each subagent's final message; Atlas will surface any `dune runtest` errors or `ocamlformat` warnings verbatim if a task fails.
06Merge the findings from all subagents into a unified `todowrite` list in the main session, for example, `todowrite "Refactor deprecated calls in src/core/"`.
07Address the identified issues in the main session using `edit` to modify OCaml files, allowing Atlas to propose changes and compute a unified diff for approval.
08Before approving changes, ask Atlas to run `ocamlformat` on modified `.ml` files to ensure style consistency, then approve the final diff.

Frequently asked questions

How does Atlas handle large OCaml projects with many `dune` files?: Atlas indexes OCaml code by AST declarations using tree-sitter, understanding each `dune` stanza and `.mli` signature. This allows it to build a comprehensive code index for large projects, which subagents can then query efficiently without loading the entire codebase into a single context window.
Can Atlas subagents run `dune runtest` on specific OCaml packages?: Yes, a `general` subagent can be instructed to run `dune runtest` within a specific `test/` directory or for a particular `dune` package. Atlas will prompt for permission before executing the command and read any compiler errors or test failures back into the plan for review.
How does Atlas ensure my OCaml code isn't sent to external servers during an audit?: Atlas can build its code index with local Ollama embeddings, keeping your OCaml source code entirely off third-party servers. This ensures that sensitive `.ml` and `.mli` files remain within your local environment during the auditing process.
What if an Atlas subagent proposes an incorrect change to an OCaml file?: Atlas computes a unified diff for every file edit, including changes to OCaml source files or `dune` configurations. This diff is surfaced for your approval before any changes are written. You can review, modify, or reject the proposed edits, maintaining full control over your OCaml codebase.
Can Atlas help enforce `ocamlformat` consistency across an OCaml repository?: Absolutely. After an Atlas subagent or the main agent makes modifications to OCaml files, you can instruct Atlas to run `ocamlformat` on the affected files. This ensures that all proposed changes adhere to your project's formatting standards before you approve the final diff, maintaining a clean and consistent OCaml codebase.
How do I split an OCaml repository for parallel subagent auditing?: You can split an OCaml repository by logical boundaries such as `dune` packages, top-level directories like `src/`, `lib/`, or `bin/`, or even by specific problem types. For example, one subagent could audit `src/parser/` for error handling, while another audits `lib/types/` for variant exhaustiveness.
Does Atlas understand OCaml module interfaces (`.mli` files)?: Yes, Atlas reads your `.mli` interface files as part of its code indexing process. This allows it to understand module signatures and types, which is crucial for tasks like ensuring variant exhaustiveness or adding an Alcotest case to a `test/dune` stanza based on exposed interfaces.

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 OCaml: A Terminal-Native AI Coding Agent for dune and opam Projects in 2026

Atlas is a terminal-native AI coding agent for OCaml in 2026. It reads dune stanzas and .mli signatures, runs dune runtest behind a prompt, and finishes with ocamlformat.

Onboard to an Unfamiliar OCaml Codebase with Atlas in 2026

Quickly build a working mental model of any OCaml repository in 2026 using Atlas. Leverage `dune` build rules, `opam` switches, and `.mli` interface files for rapid understanding and safe code exploration.

Diagnose a hanging or long-running command in OCaml with Atlas in 2026

Diagnose hanging OCaml `dune` builds or `opam` scripts with Atlas in 2026. Atlas identifies blocked input, suggests non-interactive flags, or recommends timeout adjustments.

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

Automate GitHub issue and pull request triage for OCaml projects in 2026 using Atlas. Ensure safe, permission-gated responses from trusted users, integrating with `dune` and `opam`.

Write Unit Tests for Untested Code in OCaml with Atlas in 2026

Learn how Atlas helps OCaml developers in 2026 write unit tests for untested modules. Atlas uses dune runtest, opam, and ocamlformat to integrate with your existing OCaml workflow.

Self-review Your OCaml Working Diff Before Committing with Atlas in 2026

OCaml developers in 2026 can self-review uncommitted diffs with Atlas, catching mistakes before CI. Leverage dune runtest, ocamlformat, and opam for a clean codebase.

Refactor a legacy module in OCaml with Atlas in 2026

Restructure an old OCaml module without breaking callers using Atlas. Map public surfaces, pin behavior with dune runtest, apply changes with apply_patch, and ensure style with ocamlformat.

Browse this resource hub