# Automate GitHub Issue and Pull Request Triage in Elixir with Atlas in 2026 > Atlas automates GitHub issue and pull request triage in Elixir, safely responding to events and proposing changes that respect your `mix.exs` project structure. 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. ## Key takeaways - Atlas integrates with Elixir GitHub workflows via `atlas github` for automated triage. - Permission checks ensure only `admin` or `write` users trigger Atlas in Elixir repos. - Atlas requires explicit mentions to activate, preventing accidental runs on Elixir issues. - All proposed changes to Elixir files, like `mix.exs`, are presented as diffs for approval. - Context overflow in large Elixir projects is explicitly reported with offending file names. - Atlas understands Elixir's `mix.exs`, OTP applications, and `ExUnit via mix test` for context-aware actions. ## 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 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. ## Steps 1. Create a GitHub Actions workflow file: In your Elixir project, create `.github/workflows/atlas-triage.yml` to define the automation. 2. Configure 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. 3. Restrict 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. 4. Require 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. 5. Review 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. 6. Address 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. ## FAQ ### 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. --- Canonical HTML: https://runatlas.sh/resources/stacks/automate-github-issue-and-pr-triage-in-elixir Source of truth: aeo_pages row `/resources/stacks/automate-github-issue-and-pr-triage-in-elixir` (segment: Stacks) (this file is generated from it, never hand-edited). Licence: Atlas is proprietary with a free core. It is not open source and there is no public source repository.