How does Atlas understand my Elixir `mix` project structure?

Atlas builds its code index using AST declarations via tree-sitter, allowing it to understand the structure of your Elixir `mix.exs` project, including supervision trees, contexts, and dependencies. This enables it to propose relevant changes, such as restructuring a `GenServer` or adding `ExUnit` tests.

Can Atlas add `ExUnit` tests to my Elixir application?

Yes, Atlas can be asked to add `ExUnit` tests to your Elixir application. It understands the `ExUnit via mix test` runner and will propose changes to your `test/` directory, presenting a unified diff for your approval before writing.

What Elixir tools does Atlas use for code formatting or dependency management?

Atlas works alongside your existing Elixir toolchain. While Atlas itself doesn't directly run `mix format` or `Mix and Hex`, it understands the output and structure these tools create. It can propose changes to `mix.exs` or Elixir source files, which you would then format with `mix format` and manage dependencies with `Mix and Hex`.

How does Atlas ensure only trusted users can trigger actions in my Elixir GitHub repo?

Atlas enforces strict security by checking the triggering actor's collaborator permission. It refuses to run if the user does not have `admin` or `write` access to the Elixir repository, ensuring only trusted team members can initiate automated triage.

What happens if Atlas's prompt context is too large for my Elixir codebase?

Atlas explicitly catches `ContextOverflowError` and re-throws it as a `prompt-too-large` message. This message lists the specific Elixir files that caused the overflow, helping you refine your prompt or scope for large `mix` projects.

Can Atlas commit changes directly to my Elixir repository?

Atlas computes a unified diff for every file edit and surfaces it for approval before writing. While it can stage and create commits on your behalf after approval, you always retain control to review and accept or reject proposed changes to your Elixir codebase.

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

Atlas automates GitHub issue and pull request triage in Elixir projects by integrating directly into GitHub Actions workflows, ensuring safe, permission-gated responses. It leverages your existing `mix.exs` project structure and Elixir toolchain, including `Mix and Hex` for dependencies and `ExUnit via mix test` for verification, to provide intelligent, context-aware assistance.

How does Atlas automate GitHub issue and pull request triage in Elixir projects?

Atlas automates GitHub issue and pull request triage in Elixir projects by integrating directly into GitHub Actions workflows, reading inputs from the Actions environment. In 2026, this allows Elixir developers to configure Atlas to respond to specific event types, such as new issues or pull requests, within their `mix.exs` based repositories.

Atlas provides a first-class GitHub entrypoint designed to streamline operations for Elixir developers. When wired into a GitHub workflow, the `atlas github` command reads its inputs directly from the Actions environment. This ensures that Atlas only runs when the necessary `MODEL` in `provider/model` form and `PROMPT` for specific event types are correctly provided. For instance, if a new issue is opened in an Elixir project, Atlas can be configured to draft an initial response or suggest code changes, always respecting the project's `mix.exs` and `lib/` directory structure. Atlas uses its hybrid semantic and keyword retrieval, fused by reciprocal rank fusion, to understand the Elixir codebase, indexing code by AST declarations using tree-sitter. This deep understanding allows Atlas to propose relevant actions, such as adding an `ExUnit` test or refactoring a `GenServer`, which can then be reviewed by the Elixir team.

How do I wire Atlas into a GitHub workflow for an Elixir project?

Wiring Atlas into a GitHub workflow for an Elixir project involves configuring a `.github/workflows/atlas-triage.yml` file to invoke the `atlas github` command. This setup, common in 2026 for automating repository tasks, requires specifying the `MODEL` and `PROMPT` inputs, ensuring Atlas has the necessary context to operate within your Elixir codebase.

To integrate Atlas into an Elixir project's GitHub workflow, you create a YAML file, for example, `.github/workflows/atlas-triage.yml`. Within this workflow, you define steps that call the `atlas github` command. A crucial aspect is setting the `MODEL` input, which must be in `provider/model` format (e.g., `ollama/llama3`). Additionally, for event types that require a prompt, the `PROMPT` input must be provided; otherwise, the handler fails with a `PROMPT input is required for <event> events.` message. Atlas is designed to work with Elixir projects, understanding the structure of `mix.exs` files and OTP applications. It can read your supervision tree, contexts, and dependencies, allowing it to perform tasks like suggesting changes to `lib/my_app/application.ex` or adding new modules under `lib/my_app/`. The agent's ability to use tools like `bash`, `read`, `grep`, and `edit` means it can interact directly with your Elixir source files and configuration.

How does Atlas ensure safety and trust for Elixir GitHub triage?

Atlas ensures safety and trust for Elixir GitHub triage by enforcing strict permission checks and requiring explicit triggers, preventing unauthorized or accidental runs. In 2026, Atlas checks the triggering actor's collaborator permission, refusing anyone without `admin` or `write` access to the Elixir repository, and requires a specific mention to start a run.

Safety is paramount when automating actions in an Elixir codebase. Atlas implements several mechanisms to ensure that automated triage is both secure and intentional. First, it rigorously checks the triggering actor's collaborator permission, refusing to run if the user lacks `admin` or `write` access to the repository. This prevents untrusted users from initiating potentially disruptive actions. Second, Atlas enforces that comments must mention the configured trigger, meaning a stray comment cannot accidentally start a run. This explicit mention requirement ensures that every Atlas invocation is deliberate. Furthermore, every Atlas tool call is permission-gated against `allow`, `ask`, and `deny` rules before it runs. Atlas drafts a plan in a read-only plan agent and asks for approval before switching to a build agent. It also computes a unified diff for every file edit and surfaces it for approval before writing, allowing Elixir developers to review proposed changes to files like `mix.exs` or `test/my_app_test.exs` before they are applied. Atlas snapshots file changes as git patches, so edits can be diffed and rolled back, providing an additional layer of safety.

How does Atlas handle context overflow when triaging large Elixir codebases?

Atlas explicitly handles context overflow when triaging large Elixir codebases by catching `ContextOverflowError` and re-throwing it as a clear message. This mechanism, vital for managing complex `mix` projects in 2026, lists the offending files, allowing Elixir developers to understand why a prompt might be too large.

When working with extensive Elixir projects, especially those with many OTP applications or large `lib/` directories, the context provided to the AI model can sometimes exceed its limits. Atlas is designed to handle this gracefully. It explicitly catches a `ContextOverflowError` by name and re-throws it as a user-friendly `prompt-too-large` message. This message includes a list of the specific files that contributed to the overflow, such as `lib/my_app/large_module.ex` or `priv/repo/migrations/`. This explicit feedback is crucial for Elixir developers, as it allows them to identify and address the source of the context issue, perhaps by refining the prompt or adjusting the scope of the triage task. Atlas's ability to index code by AST declarations using tree-sitter, rather than blind line windows, helps in providing more precise context, but even with this, large codebases can present challenges. The clear error reporting ensures that developers can maintain control and understanding over the agent's operations within their Elixir `mix` projects.

Step by step

01Create a GitHub Actions workflow file: In your Elixir project, create `.github/workflows/atlas-triage.yml` to define the automation.
02Configure the `atlas github` command: Within the workflow, define a step to run `atlas github`, ensuring you set the `MODEL` input (e.g., `ollama/llama3`) and the `PROMPT` input for relevant event types.
03Restrict trigger permissions: Ensure the workflow's `permissions` are set appropriately and rely on Atlas's built-in check that the triggering actor has `admin` or `write` access to your Elixir repository.
04Require explicit mention: Configure the workflow to trigger on comment events, knowing Atlas will enforce that the comment explicitly mentions the configured trigger to start a run.
05Review proposed changes: When Atlas proposes changes to your Elixir codebase (e.g., modifying `mix.exs` or adding `ExUnit` tests), review the unified diff it surfaces for approval before writing, using Atlas's built-in diff and rollback capabilities.
06Address context overflow: If Atlas reports a `prompt-too-large` message listing offending Elixir files, refine your prompt or adjust the scope of the triage task to fit within the model's context window.

Frequently asked questions

How does Atlas understand my Elixir `mix` project structure?: Atlas builds its code index using AST declarations via tree-sitter, allowing it to understand the structure of your Elixir `mix.exs` project, including supervision trees, contexts, and dependencies. This enables it to propose relevant changes, such as restructuring a `GenServer` or adding `ExUnit` tests.
Can Atlas add `ExUnit` tests to my Elixir application?: Yes, Atlas can be asked to add `ExUnit` tests to your Elixir application. It understands the `ExUnit via mix test` runner and will propose changes to your `test/` directory, presenting a unified diff for your approval before writing.
What Elixir tools does Atlas use for code formatting or dependency management?: Atlas works alongside your existing Elixir toolchain. While Atlas itself doesn't directly run `mix format` or `Mix and Hex`, it understands the output and structure these tools create. It can propose changes to `mix.exs` or Elixir source files, which you would then format with `mix format` and manage dependencies with `Mix and Hex`.
How does Atlas ensure only trusted users can trigger actions in my Elixir GitHub repo?: Atlas enforces strict security by checking the triggering actor's collaborator permission. It refuses to run if the user does not have `admin` or `write` access to the Elixir repository, ensuring only trusted team members can initiate automated triage.
What happens if Atlas's prompt context is too large for my Elixir codebase?: Atlas explicitly catches `ContextOverflowError` and re-throws it as a `prompt-too-large` message. This message lists the specific Elixir files that caused the overflow, helping you refine your prompt or scope for large `mix` projects.
Can Atlas commit changes directly to my Elixir repository?: Atlas computes a unified diff for every file edit and surfaces it for approval before writing. While it can stage and create commits on your behalf after approval, you always retain control to review and accept or reject proposed changes to your Elixir codebase.

Try Atlas in your terminal

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

Install Atlas

Related guides

Automate GitHub Issue and Pull Request Triage with Atlas (2026 Workflow)

How to automate GitHub issue and pull request triage with Atlas in 2026: the atlas github command checks the actor has admin or write permission before it does anything.

Atlas for Elixir in 2026

Adopt Atlas, the terminal-native AI coding agent, for Elixir development in 2026. Enhance productivity with deep code understanding, safety features, and direct integration into mix projects and OTP applications.

Trace a Runtime Bug From a Stack Trace in Elixir with Atlas (2026)

Trace an Elixir runtime bug from a stack trace in 2026 with Atlas: read each frame at its offset, grep for the error message, findReferences the callers, fix, add ExUnit.

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

Learn how Atlas helps Elixir developers in 2026 add robust unit tests to untested modules, matching existing repo conventions using ExUnit via mix test.

Onboard to an unfamiliar codebase in Elixir with Atlas (2026)

How to onboard to an unfamiliar Elixir codebase in 2026 with Atlas: codebase_search over the semantic index, glob across mix.exs projects, and ExUnit via mix test.

Refactor a legacy module in Elixir with Atlas in 2026

Refactor Elixir modules safely in 2026 with Atlas, the terminal-native AI coding agent. Pin behavior with ExUnit via mix test, map callsites with LSP, and apply changes with atomic patches.

Locate Where a Behavior Is Implemented in Elixir With Atlas (2026)

How to locate where a behavior is implemented in an Elixir codebase with Atlas in 2026: codebase_search for meaning, grep for text, and the lsp tool for symbols.

Document an Elixir Module with a README in 2026 using Atlas

Generate accurate, up-to-date README documentation for your Elixir modules with Atlas. Leverage Mix, Hex, and ExUnit for verified, traceable docs.

Browse this resource hub