How does Atlas ensure only trusted users can trigger actions on my Erlang GitHub repo?

Atlas enforces security by checking the triggering actor's collaborator permission, refusing to run if they lack `admin` or `write` access. Additionally, it requires an explicit mention (e.g., `@atlas triage`) in comments to activate, preventing accidental or unauthorized runs on your Erlang project.

What Erlang tools does Atlas use when responding to GitHub events?

Atlas integrates directly with standard Erlang tools. It uses `rebar3` for build and package management, including running `rebar3 eunit` or `rebar3 ct` for tests. It also runs `erlfmt` on modified Erlang source files to ensure code style consistency.

Can Atlas modify my Erlang code, and how is that process made safe?

Yes, Atlas can modify Erlang code. The process is made safe through permission-gated tool calls, a read-only plan agent that drafts proposed changes, and a mandatory unified diff approval step. You review and approve every change to your `src/*.erl` files before they are written.

How does Atlas handle large Erlang codebases to avoid context overflow?

Atlas indexes Erlang code by AST declarations using tree-sitter, providing more precise context than line-based methods. It explicitly catches `ContextOverflowError` and re-throws it as a `prompt-too-large` message, listing offending files, allowing you to manage context effectively for your Erlang project.

What specific Erlang project files does Atlas interact with?

Atlas is designed to interact with `rebar.config`, `src/*.app.src`, and Erlang source files in `src/` and test suites in `test/`. It understands Erlang idioms like supervisor callbacks and `gen_server` modules, ensuring relevant interactions within your project structure.

How do I configure Atlas to respond to specific GitHub event types in Erlang?

You configure Atlas by providing the `PROMPT` input within your GitHub Actions workflow for the specific event types you want it to handle. For example, you can define a `PROMPT` for `pull_request_opened` events to automate initial responses to new Erlang contributions.

Does Atlas support local embeddings for Erlang code?

Yes, Atlas can build its code index with local Ollama embeddings. This capability ensures that your Erlang codebase remains on your local infrastructure, preventing sensitive code from being sent to third-party servers during the indexing process.

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

Atlas automates GitHub issue and pull request triage for Erlang projects by integrating directly into GitHub Actions, leveraging `rebar3` for project structure and `erlfmt` for style consistency, ensuring safe, permission-gated responses from trusted users. This allows Erlang developers in 2026 to streamline their workflow, letting Atlas handle initial responses and code suggestions within their familiar `rebar.config` environment.

How to Integrate Atlas for Erlang GitHub Triage

Integrating Atlas into your Erlang GitHub workflow in 2026 requires wiring the `atlas github` command into a GitHub Actions workflow file, typically located under `.github/workflows/`. This command needs a `MODEL` in `provider/model` form and a `PROMPT` input for specific event types, ensuring Atlas knows exactly how to respond to issues and pull requests.

To automate GitHub issue and pull request triage for your Erlang project, you must configure a GitHub Actions workflow that invokes the `atlas github` command. This command is designed to read its inputs directly from the Actions environment, refusing to run if critical parameters are missing or incorrect. Specifically, you must provide the `MODEL` input, specifying the AI model Atlas should use (e.g., `ollama/llama3`), and the `PROMPT` input for any event types that require a custom response. For instance, if you want Atlas to greet new contributors on their first pull request, you would define a `PROMPT` for `pull_request_opened` events. Atlas ensures that if a `PROMPT` is required for a given event type, it will fail upfront with a clear message like `PROMPT input is required for <event> events` if it's not provided. This setup allows Erlang developers to precisely control Atlas's behavior within their `rebar3`-managed repositories.

Ensuring Secure Erlang Workflow Automation with Atlas

Atlas ensures secure automation for Erlang GitHub workflows by implementing strict permission checks and requiring explicit mentions, preventing unauthorized or accidental runs. The system verifies that the triggering actor possesses `admin` or `write` collaborator permissions before any action is taken, a critical safeguard in 2026 for maintaining code integrity in `rebar3` projects.

Security is paramount when automating responses to GitHub events in an Erlang codebase. Atlas enforces stringent security measures to ensure that only trusted users can trigger its actions. Before processing any event, Atlas checks the triggering actor's collaborator permission level, refusing to run if the actor does not have `admin` or `write` access to the repository. This prevents malicious or unauthorized users from leveraging Atlas to interact with your Erlang project. Furthermore, to avoid stray comments from inadvertently starting a run, Atlas's handler enforces that comments must explicitly mention the configured trigger (e.g., `@atlas triage`). This dual-layer security approach provides Erlang teams with confidence that their `rebar.config` and `src/*.app.src` files are protected, and Atlas only acts when explicitly requested by a trusted party.

Managing Erlang Code Context and Overflow with Atlas

Atlas efficiently manages context for Erlang codebases by indexing code via AST declarations using tree-sitter, rather than relying on blind line windows. This precise indexing helps prevent `ContextOverflowError` when dealing with large Erlang modules or complex supervision trees, ensuring that even in 2026, Atlas can process extensive code without exceeding model limits.

When working with large Erlang applications, managing the context provided to an AI agent is crucial. Atlas addresses this challenge by indexing code through AST declarations using tree-sitter, offering a more intelligent approach than simple line-based windows. This method allows Atlas to understand the structure of Erlang modules, `gen_server` callbacks, and `rebar.config` definitions, providing more relevant context to the model. Atlas also explicitly handles context overflow: if a `ContextOverflowError` occurs, it is caught by name and re-thrown as a user-friendly `prompt-too-large` message, listing the offending files. This explicit error handling ensures that Erlang developers are immediately informed if a particular set of files or a complex `handle_call` clause exceeds the model's context window, allowing them to adjust the scope of the request or the `PROMPT` accordingly. Atlas can also build its code index with local Ollama embeddings, keeping sensitive Erlang code off third-party servers.

Atlas's Interaction with the Erlang Toolchain

Atlas is designed to work direct within the Erlang/OTP ecosystem, directly interacting with standard tools like `rebar3` for package management and build tasks, and `erlfmt` for code formatting. This integration ensures that any code modifications proposed by Atlas, such as adding a `handle_call` clause or a new `eunit` test, adhere to the project's established Erlang conventions and build processes in 2026.

Atlas deeply understands the Erlang toolchain, making it an invaluable asset for automating tasks in `rebar3`-based projects. When Atlas proposes code changes, such as adding a new `gen_server` module or modifying a supervisor callback, it can be instructed to run `rebar3 eunit` or `rebar3 ct` to verify the changes. These test runs are permission-gated, requiring explicit approval before execution, ensuring that Atlas doesn't introduce regressions without developer oversight. Furthermore, to maintain code style consistency across the Erlang codebase, Atlas can run `erlfmt` on any touched modules. This ensures that the unified diff presented for approval matches the project's `erlfmt` configuration, preventing style-related conflicts and making code reviews smoother. Atlas is configured to run in applications with a `rebar.config` and `src/*.app.src`, and can map supervisor callbacks, `gen_server` modules, and `relx` release configurations.

Safe Code Modifications in Erlang with Atlas

Atlas ensures safe code modifications in Erlang projects through a multi-stage approval process, including a read-only plan agent and explicit diff approval. Before any changes are written to your `src/*.erl` files or `rebar.config`, Atlas drafts a plan and computes a unified diff, providing full transparency and control to the Erlang developer in 2026.

The safety of code modifications is a core tenet of Atlas's design, especially critical in Erlang's hot code loading environments. Every Atlas tool call, including `bash`, `read`, `grep`, and `edit`, is permission-gated against `allow`, `ask`, and `deny` rules before it runs. This means that before Atlas can even attempt to modify an Erlang source file or configuration, it must pass these checks. Atlas then drafts a plan in a read-only plan agent, presenting its intended actions to the user for review. Only after explicit approval does it switch to a build agent to execute the plan. For every file edit, Atlas computes a unified diff and surfaces it for approval, allowing Erlang developers to review the exact changes to their `src/*.erl` files, `rebar.config`, or `test/` suites before they are written. Atlas also snapshots file changes as git patches, enabling easy diffing and rolling back of edits, providing an additional layer of safety and control over your Erlang codebase.

Step by step

01Create a GitHub Actions workflow file (e.g., `.github/workflows/atlas-triage.yml`) in your Erlang project.
02Configure the `atlas github` command within the workflow, setting the `MODEL` input (e.g., `ollama/llama3`) and `PROMPT` for relevant event types.
03Ensure the workflow's `on` trigger restricts execution to trusted users with `admin` or `write` permissions on the Erlang repository.
04Require a specific mention (e.g., `@atlas triage`) in comments to activate Atlas for issue or pull request events.
05Let Atlas draft a plan for a proposed change to an Erlang module, such as adding a `handle_call` clause to a `gen_server`.
06Review and approve the unified diff presented by Atlas for any modifications to `src/*.erl` files or `rebar.config`.
07Approve Atlas to run `rebar3 eunit` or `rebar3 ct` to validate the proposed Erlang code changes.
08Instruct Atlas to run `erlfmt` on any modified Erlang source files to ensure style consistency before committing.

Frequently asked questions

How does Atlas ensure only trusted users can trigger actions on my Erlang GitHub repo?: Atlas enforces security by checking the triggering actor's collaborator permission, refusing to run if they lack `admin` or `write` access. Additionally, it requires an explicit mention (e.g., `@atlas triage`) in comments to activate, preventing accidental or unauthorized runs on your Erlang project.
What Erlang tools does Atlas use when responding to GitHub events?: Atlas integrates directly with standard Erlang tools. It uses `rebar3` for build and package management, including running `rebar3 eunit` or `rebar3 ct` for tests. It also runs `erlfmt` on modified Erlang source files to ensure code style consistency.
Can Atlas modify my Erlang code, and how is that process made safe?: Yes, Atlas can modify Erlang code. The process is made safe through permission-gated tool calls, a read-only plan agent that drafts proposed changes, and a mandatory unified diff approval step. You review and approve every change to your `src/*.erl` files before they are written.
How does Atlas handle large Erlang codebases to avoid context overflow?: Atlas indexes Erlang code by AST declarations using tree-sitter, providing more precise context than line-based methods. It explicitly catches `ContextOverflowError` and re-throws it as a `prompt-too-large` message, listing offending files, allowing you to manage context effectively for your Erlang project.
What specific Erlang project files does Atlas interact with?: Atlas is designed to interact with `rebar.config`, `src/*.app.src`, and Erlang source files in `src/` and test suites in `test/`. It understands Erlang idioms like supervisor callbacks and `gen_server` modules, ensuring relevant interactions within your project structure.
How do I configure Atlas to respond to specific GitHub event types in Erlang?: You configure Atlas by providing the `PROMPT` input within your GitHub Actions workflow for the specific event types you want it to handle. For example, you can define a `PROMPT` for `pull_request_opened` events to automate initial responses to new Erlang contributions.
Does Atlas support local embeddings for Erlang code?: Yes, Atlas can build its code index with local Ollama embeddings. This capability ensures that your Erlang codebase remains on your local infrastructure, preventing sensitive code from being sent to third-party servers during the indexing process.

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 Erlang in 2026

Atlas is a terminal-native AI coding agent for Erlang/OTP in 2026. Run it in an app with a rebar.config, map supervisors and gen_server modules, review every diff.

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

In 2026, Erlang developers use Atlas to write unit tests for untested modules, leveraging `rebar3 eunit` and `erlfmt` to match existing project conventions and ensure code quality.

Onboard to an unfamiliar codebase in Erlang with Atlas in 2026

Erlang developers in 2026 can use Atlas to quickly build a mental model of unfamiliar rebar3 projects. Understand supervision trees, gen_server modules, and application structure without reading every file, leveraging

Run Atlas Headless in CI in Erlang with Atlas in 2026

Automate Erlang development in CI/CD with Atlas. Run Atlas headless, integrate with rebar3 and erlfmt, and get machine-readable output for Erlang/OTP projects in 2026.

Refactor a Legacy Erlang Module with Atlas in 2026

Safely refactor Erlang modules in 2026 using Atlas, the terminal-native AI coding agent. Map callsites, verify behavior with rebar3 eunit, and apply changes with precision, all while maintaining Erlang code style with

Plan a Multi-File Change Before Editing in Erlang with Atlas in 2026

In 2026, Erlang developers use Atlas to plan and review complex multi-file changes, ensuring design approval before modifying a single line of code or running rebar3. Securely design Erlang system updates.

Review a Pull Request in Erlang with Atlas in 2026

Streamline Erlang pull request reviews in 2026 with Atlas, the terminal-native AI coding agent. Catch subtle bugs by leveraging Erlang's rebar3, eunit, and erlfmt toolchain for comprehensive context.

Browse this resource hub