How do I run Atlas in CI for Assembly without user interaction?

Run `atlas run` with your prompt and the `--format json` flag in your Assembly project directory. Ensure all necessary tools like `bash` and `edit` are pre-approved in your Atlas configuration, as headless runs cannot prompt for user input.

Can Atlas understand x86-64 and ARM64 Assembly code?

Yes, Atlas indexes Assembly code by AST declarations using tree-sitter, allowing it to understand x86-64 and ARM64 specifics like register allocation, calling conventions (System V, AAPCS64), sections, and labels within `.asm` or `.S` files.

How does Atlas integrate with `make check` for Assembly testing?

Atlas can execute `make check` via its `bash` tool, allowing it to run your Assembly test harness. This can be part of a plan where Atlas modifies code and then verifies its changes by running the tests, all within a headless CI environment.

How do I ensure Atlas maintains Assembly code style with `asmfmt`?

After Atlas makes modifications to `.asm` or `.S` files, you can configure it (or your CI script) to run `asmfmt` on the touched files using the `bash` tool. This ensures alignment and column style consistency, adhering to your project's formatting standards.

What kind of output does Atlas provide for CI automation in Assembly?

When run with `--format json`, Atlas streams raw event data to stdout. This machine-readable output includes details of tool calls, unified diffs for file edits, and agent progress, enabling automated parsing and reaction by your CI pipeline for Assembly projects.

Can Atlas make changes to Assembly files in CI?

Yes, Atlas can use its `edit` tool to modify `.asm` or `.S` files. For headless CI, the `edit` tool must be pre-approved in the Atlas permission configuration. Atlas computes a unified diff for every edit, which is available in the JSON output for review.

How does Atlas handle security when running tools like `bash` in CI for Assembly?

Atlas's permission system gates every tool call. In headless CI, tools like `bash` must be explicitly `allow`-listed in your configuration. Atlas also drafts a plan in a read-only agent and surfaces unified diffs for approval, even if that approval is pre-configured for CI.

Run Atlas Headless in CI for Assembly in 2026

To run an Atlas session non-interactively in a CI pipeline and retrieve machine-readable output for your Assembly projects, invoke `atlas run` with the `--format json` flag. This allows Atlas to integrate directly with your existing `make check` test runner and `asmfmt` formatter, providing structured event streams for automated processing of x86-64 and ARM64 codebases.

How to Invoke Atlas Headless in Assembly CI Pipelines

Running Atlas non-interactively in your Assembly CI pipeline is straightforward with `atlas run`. By 2026, developers routinely use this command to automate tasks, ensuring that code changes in `.asm` or `.S` files are analyzed and potentially modified without human intervention, streamlining the development process.

The `atlas run` command is specifically designed for non-interactive execution within CI environments. When invoked, it processes a single prompt, streams events to standard output, and then exits once the session becomes idle. For Assembly projects, you would typically run `atlas run` in the same directory as your `.asm` or `.S` source files and your `Makefile`. This allows Atlas to leverage its AST indexing capabilities, built using tree-sitter, to understand sections, labels, and calling conventions like System V or AAPCS64. For example, to ask Atlas to explain a hot loop in `my_routine.asm`, you would pass the prompt directly as an argument. This headless mode is crucial for integrating Atlas into automated workflows where continuous analysis and modification of x86-64 or ARM64 assembly code are required.

How to Get Machine-Readable JSON Output from Atlas for Assembly

To enable downstream pipeline steps to parse Atlas's output for Assembly projects, specify the `--format json` flag. This ensures that instead of human-readable prose, Atlas streams raw event data, making it easy for scripts to consume and act upon the agent's actions, such as a proposed change to a `.S` file in 2026.

When `atlas run` is executed with `--format json`, it emits a structured stream of events to stdout. This machine-readable format is essential for CI pipelines that need to programmatically react to Atlas's operations, such as identifying specific tool calls, parsing unified diffs, or extracting results from `bash` commands. For instance, if Atlas uses the `edit` tool to modify `vector_add.asm`, the JSON output will contain the details of that edit, including the computed unified diff. This allows your CI system to automatically review changes, trigger further actions like running `asmfmt` on touched files, or even automatically stage and commit changes using Atlas's git integration capabilities, which can snapshot file changes as git patches.

Ensuring Safety and Permissions for Headless Assembly Operations

Headless Atlas runs in CI require pre-approved tool permissions, as there's no interactive user to respond to 'ask' prompts. By 2026, configuring these permissions in advance is a standard practice, ensuring that Atlas can safely use tools like `bash`, `read`, `edit`, and `todowrite` on your Assembly codebase without unexpected interruptions.

Atlas employs a robust permission system where every tool call is gated against `allow`, `ask`, and `deny` rules. In a headless CI environment, any `ask` rule would halt the process, as there is no terminal-native TUI (rendered with SolidJS through OpenTUI) for user interaction. Therefore, it is critical to pre-approve the specific tools Atlas needs for your Assembly tasks. For example, if Atlas is expected to annotate register usage in `kernel_entry.S` and then modify it, the `edit` tool must be explicitly allowed. Similarly, if it needs to run `make check` or `asmfmt` via `bash`, the `bash` tool must be permitted. Atlas also drafts a plan in a read-only plan agent before switching to a build agent, and computes a unified diff for every file edit, surfacing it for approval. In a headless setup, these safety mechanisms are still active, but the final approval for writing changes must be handled by pre-configured permissions or by parsing the JSON output and implementing external approval logic.

Integrating Atlas with Assembly Toolchain: `make check` and `asmfmt`

Atlas direct integrates with the standard Assembly toolchain, including `make check` for testing and `asmfmt` for formatting. In 2026, this integration allows Atlas to not only understand your x86-64 and ARM64 code but also to ensure that any modifications adhere to your project's established quality and style guidelines, running these tools behind a permission prompt.

Atlas is designed to operate within your existing development ecosystem. For Assembly projects, this means it can be configured to use `nasm` or the GNU assembler to build your code and then run your test harness using `make check`. When Atlas proposes changes to files like `syscall_handler.S`, it can be instructed to keep alignment and column style consistent by running `asmfmt` on the touched files. This is achieved by allowing Atlas to execute `bash` commands that invoke these tools. Furthermore, Atlas can read git branches, status, and diffs, and can stage and create commits on your behalf, making it a powerful agent for automating the entire code modification and review cycle within your CI pipeline. You can also set the model explicitly using the `provider/model` form, ensuring Atlas uses the correct AI model for your specific Assembly tasks.

Step by step

01Configure Tool Permissions: Before running, pre-approve necessary Atlas tools (`bash`, `read`, `edit`, `todowrite`) in your Atlas configuration, as headless runs cannot prompt for approval.
02Set the AI Model: Explicitly define the AI model using the `--model provider/model` flag, for example, `--model ollama/codellama:7b`, to ensure Atlas uses the desired model for your Assembly tasks.
03Invoke Atlas Headless: Execute `atlas run` in your Assembly project's root directory (where `.asm` or `.S` sources and `Makefile` reside) with your prompt and the `--format json` flag. For example: `atlas run "Explain the register usage in the _start routine in boot.S and suggest an optimization." --format json --model ollama/codellama:7b`
04Parse Machine-Readable Output: Capture the JSON event stream from stdout in your CI script. Parse this output to identify Atlas's actions, such as proposed `edit` operations on `boot.S` or `bash` commands.
05Automate Code Review and Formatting: If Atlas proposes changes, extract the unified diff from the JSON output. If changes are accepted, trigger `asmfmt` on the modified `.asm` or `.S` files via a `bash` command to maintain code style. Example: `asmfmt path/to/modified_file.S`
06Run Assembly Tests: After any modifications and formatting, instruct Atlas (or your CI script) to execute your test suite using `make check` to verify correctness. Example: `atlas run --command "bash make check" --format json --model ollama/codellama:7b`
07Handle Session Resumption (Optional): If a pipeline step fails or needs further iteration, resume a prior Atlas session using `--continue` or `--session <session_id>` to build upon previous work.

Frequently asked questions

How do I run Atlas in CI for Assembly without user interaction?: Run `atlas run` with your prompt and the `--format json` flag in your Assembly project directory. Ensure all necessary tools like `bash` and `edit` are pre-approved in your Atlas configuration, as headless runs cannot prompt for user input.
Can Atlas understand x86-64 and ARM64 Assembly code?: Yes, Atlas indexes Assembly code by AST declarations using tree-sitter, allowing it to understand x86-64 and ARM64 specifics like register allocation, calling conventions (System V, AAPCS64), sections, and labels within `.asm` or `.S` files.
How does Atlas integrate with `make check` for Assembly testing?: Atlas can execute `make check` via its `bash` tool, allowing it to run your Assembly test harness. This can be part of a plan where Atlas modifies code and then verifies its changes by running the tests, all within a headless CI environment.
How do I ensure Atlas maintains Assembly code style with `asmfmt`?: After Atlas makes modifications to `.asm` or `.S` files, you can configure it (or your CI script) to run `asmfmt` on the touched files using the `bash` tool. This ensures alignment and column style consistency, adhering to your project's formatting standards.
What kind of output does Atlas provide for CI automation in Assembly?: When run with `--format json`, Atlas streams raw event data to stdout. This machine-readable output includes details of tool calls, unified diffs for file edits, and agent progress, enabling automated parsing and reaction by your CI pipeline for Assembly projects.
Can Atlas make changes to Assembly files in CI?: Yes, Atlas can use its `edit` tool to modify `.asm` or `.S` files. For headless CI, the `edit` tool must be pre-approved in the Atlas permission configuration. Atlas computes a unified diff for every edit, which is available in the JSON output for review.
How does Atlas handle security when running tools like `bash` in CI for Assembly?: Atlas's permission system gates every tool call. In headless CI, tools like `bash` must be explicitly `allow`-listed in your configuration. Atlas also drafts a plan in a read-only agent and surfaces unified diffs for approval, even if that approval is pre-configured for CI.

Try Atlas in your terminal

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

Install Atlas

Related guides

Run Atlas Headless in CI with Atlas (2026 Workflow)

How to run Atlas headless in CI in 2026: atlas run sends one prompt and exits when the session goes idle, with --format json, --command, and --continue for pipeline steps.

Atlas for Assembly: Registers, Calling Conventions, and nasm in 2026

Atlas is a terminal-native AI coding agent for Assembly in 2026. It reads .asm and .S sources, tracks System V and AAPCS64 calling conventions, and assembles with nasm behind a prompt.

Review a Pull Request in Assembly with Atlas in 2026

In 2026, Atlas helps Assembly developers review pull requests by understanding x86-64 and ARM64 code, checking calling conventions, and integrating with `make check` and `asmfmt` for thorough, context-aware feedback.

Locate where a behavior is implemented in Assembly with Atlas in 2026

In 2026, Atlas helps Assembly developers pinpoint exact file and symbol locations for specific behaviors, integrating with `nasm`, `make check`, and `asmfmt` for x86-64 and ARM64.

Refactor a legacy module in Assembly with Atlas in 2026

Refactor legacy Assembly modules safely in 2026 with Atlas, the terminal-native AI coding agent. Use make check, asmfmt, and nasm to restructure code without breaking callers.

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

Catch your own mistakes in uncommitted Assembly diffs using Atlas in 2026. Integrate with `make check` and `asmfmt` to ensure quality before review or CI.

Write Unit Tests for Untested Assembly Code with Atlas in 2026

In 2026, Assembly developers use Atlas to write unit tests for untested x86-64 and ARM64 modules. Learn how Atlas leverages `make check` and `asmfmt` to integrate new tests direct into your existing Assembly

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

Streamline GitHub issue and pull request triage for Assembly codebases using Atlas. Ensure safe, trusted automation with real-time feedback and strict permission controls.

Browse this resource hub