How do I get machine-readable output from Atlas in an Unreal Engine CI pipeline?

To get machine-readable output, use `atlas run --format json`. This streams events as raw JSON to stdout, which can be parsed by subsequent pipeline steps in your Unreal Engine CI.

Can Atlas modify Unreal Engine's `Build.cs` files in CI?

Yes, Atlas is designed to understand and modify `Build.cs` files, correctly adding module dependencies using Unreal Build Tool rules before adding corresponding `#include` directives in C++ source.

How does Atlas handle permissions for tools like `bash` or `edit` in a headless Unreal Engine CI run?

In a headless CI run, all necessary tools (e.g., `bash`, `read`, `edit`) must be pre-approved in Atlas's permission configuration. This bypasses interactive 'ask' prompts, ensuring the pipeline runs smoothly.

Does Atlas support Unreal Engine's `clang-format` for code style?

Yes, Atlas can apply the engine's `.clang-format` configuration after drafting code changes, ensuring all generated or modified Unreal Engine C++ code adheres to the Epic style guide.

Can Atlas generate and run Unreal Automation Framework tests?

Atlas can write Automation Spec tests and execute them through `UnrealEditor-Cmd`, leveraging the Unreal Automation Framework. This allows for automated test generation and validation within your CI pipeline.

How does Atlas index Unreal Engine C++ code for better understanding?

Atlas indexes Unreal Engine C++ code by AST declarations using tree-sitter, not blind line windows. This allows it to understand `UCLASS`, `UPROPERTY`, `UFUNCTION` macros and `Build.cs` dependencies for accurate code analysis and modification.

What happens if an Atlas session needs to be resumed in an Unreal Engine CI pipeline?

You can resume or fork a prior Atlas session using `atlas run --continue`, `--session`, or `--fork`. This allows a pipeline step to build on an earlier run or recover from an interruption, maintaining context.

Run Atlas Headless in CI for Unreal Engine in 2026

To run an Atlas session non-interactively in an Unreal Engine CI pipeline and retrieve machine-readable output, developers in 2026 use the `atlas run --format json` command. This approach allows Atlas to integrate direct with existing Unreal Build Tool (Build.cs) and Unreal Automation Framework workflows, ensuring automated code generation, testing, and formatting adhere to Epic's style guide without manual intervention.

How to Run Atlas Headless in Unreal Engine CI Pipelines

Running Atlas headless in an Unreal Engine CI pipeline in 2026 is achieved by invoking `atlas run` with specific arguments. This command's default mode is non-interactive, sending a single prompt and exiting when the session goes idle, making it ideal for automated environments.

For Unreal Engine projects, `atlas run` is designed to execute Atlas sessions without requiring user interaction. When integrated into a CI/CD pipeline, the command sends a single prompt to Atlas, which then processes the request and streams events to standard output. The session automatically terminates once all tasks are completed and the agent becomes idle. This enables automated code modifications, dependency updates in `Build.cs` files, and test generation using the Unreal Automation Framework, all within a controlled pipeline environment. To ensure Atlas operates effectively, the CI environment must contain a `.uproject` file and the standard `Source/` module folders, allowing Atlas to correctly index the Unreal Engine project structure.

Getting Machine-Readable Output from Atlas in Unreal Engine CI

To obtain machine-readable output from Atlas for subsequent pipeline steps in 2026, developers must pass the `--format json` flag to the `atlas run` command. This ensures that the event stream is structured as raw JSON, rather than human-readable prose, facilitating automated parsing.

When an Unreal Engine CI pipeline requires structured data from an Atlas session, the `--format json` argument is crucial. This flag instructs Atlas to output its event stream as a series of JSON objects, which can be easily consumed and parsed by other automated tools or scripts in the pipeline. This is particularly useful for tasks such as verifying code changes, logging agent actions, or triggering downstream processes based on Atlas's output. For instance, a pipeline step could parse the JSON output to confirm that Atlas successfully added a module dependency to a `Build.cs` file or generated a new Automation Spec test, providing concrete, verifiable results for the CI system.

Configuring Atlas Permissions for Headless Unreal Engine Operations

In a headless Atlas run for Unreal Engine in 2026, pre-approving necessary tools through the permission configuration is mandatory. Since there's no interactive user to respond to 'ask' prompts, all required tools like `bash`, `read`, `edit`, and `todowrite` must be explicitly allowed beforehand.

Atlas's robust permission system, which gates every tool call against allow, ask, and deny rules, requires specific handling in a headless Unreal Engine CI environment. Because a pipeline run lacks an interactive user to approve actions, all tools that Atlas might need to use - such as `bash` for executing commands, `read` for accessing files, `edit` for modifying code, and `todowrite` for creating temporary files - must be pre-approved in the Atlas permission configuration. This ensures that Atlas can perform its tasks, like updating `Build.cs` files or applying `clang-format` changes, without encountering permission blocks that would halt the automated session. This proactive configuration is vital for maintaining the non-interactive nature of CI operations.

Managing Unreal Engine Dependencies with Atlas and Build.cs

Atlas excels at managing Unreal Engine module dependencies by understanding `Build.cs` files, a critical aspect often missed by other C++ agents. In 2026, Atlas is configured to add a module dependency in `Build.cs` before adding the corresponding include, ensuring correct project structure.

Unreal Engine projects rely heavily on `Build.cs` files, managed by Unreal Build Tool, to declare module dependencies. Atlas is specifically designed to understand this system. When tasked with adding a new dependency, Atlas first modifies the relevant `Build.cs` file to include the new module, then proceeds to add the necessary `#include` directives in the C++ source files. This order of operations is crucial for Unreal Engine's compilation process and prevents common build errors. Atlas's ability to parse `Build.cs` files and recognize `UCLASS`, `UPROPERTY`, and `UFUNCTION` macros, built on its AST declarations using tree-sitter, allows it to make intelligent and context-aware modifications to Unreal Engine C++ code, ensuring that changes are both syntactically and semantically correct within the engine's framework.

Automating Unreal Engine Code Formatting with Atlas and clang-format

Ensuring Unreal Engine code adheres to Epic's style guide is automated by Atlas, which integrates with `clang-format`. After Atlas drafts code changes, it can apply the engine's `.clang-format` configuration, ensuring consistent formatting across the codebase in 2026.

Code consistency is paramount in large Unreal Engine projects. Atlas facilitates this by integrating with `clang-format`, the standard formatter used by Epic Games. After Atlas generates or modifies C++ code, it can be instructed to apply the project's `.clang-format` configuration, which typically mirrors the Epic style guide. This ensures that all new or altered code automatically conforms to the established formatting rules, eliminating manual formatting efforts and maintaining a clean, readable codebase. The process involves Atlas computing a unified diff for every file edit and surfacing it for approval (or pre-approval in headless mode) before writing, allowing developers to review the formatting changes alongside the functional ones.

Generating and Running Unreal Engine Automation Tests with Atlas

Atlas can generate Automation Spec tests for Unreal Engine and execute them through `UnrealEditor-Cmd` behind a permission prompt. This capability allows developers in 2026 to automate test creation and validation within their CI pipelines, leveraging the Unreal Automation Framework.

The Unreal Automation Framework is the cornerstone of testing in Unreal Engine. Atlas can be instructed to write new Automation Spec tests, understanding the structure and requirements of these tests within the Unreal Engine context. Once generated, Atlas can then run these tests using `UnrealEditor-Cmd`, the command-line interface for the Unreal Editor. In a headless CI environment, the execution of these tests would be pre-approved through the permission configuration, allowing the pipeline to automatically validate code changes. Atlas's ability to read `git` branches, status, and diffs, and to snapshot file changes as `git` patches, means that test generation and execution can be tightly integrated with version control, providing a robust system for ensuring code quality and preventing regressions in Unreal Engine projects.

Step by step

01Initialize your Unreal Engine project with Atlas by ensuring a `.uproject` file and `Source/` module folders are present, allowing Atlas to index `UCLASS`, `UPROPERTY`, and `UFUNCTION` macros.
02Configure Atlas permissions to pre-approve `bash`, `read`, `edit`, and `todowrite` tools in your CI environment, as headless runs cannot prompt for approval.
03Invoke `atlas run` with your specific prompt, ensuring `--format json` is passed for machine-readable output, and explicitly set the model using `provider/model` form (e.g., `atlas run --format json --model github/copilot-gpt4 'Add a new module dependency to Build.cs for MyPlugin and create a basic UCLASS.'`).
04Monitor the JSON event stream from `stdout` to track Atlas's progress and verify actions, such as modifications to `Build.cs` files or new C++ source generation.
05Allow Atlas to add module dependencies in `Build.cs` using Unreal Build Tool rules before adding corresponding `#include` statements, ensuring correct Unreal Engine project structure.
06Approve the diffs generated by Atlas for any code changes, then let Atlas apply the engine's `.clang-format` configuration to ensure adherence to the Epic style guide.
07Instruct Atlas to write Automation Spec tests and run them through `UnrealEditor-Cmd` via the Unreal Automation Framework, validating the generated or modified code.
08Optionally, use `atlas run --continue` or `--session` to resume a prior Atlas session if a pipeline step needs to build on an earlier run or recover from an interruption.

Frequently asked questions

How do I get machine-readable output from Atlas in an Unreal Engine CI pipeline?: To get machine-readable output, use `atlas run --format json`. This streams events as raw JSON to stdout, which can be parsed by subsequent pipeline steps in your Unreal Engine CI.
Can Atlas modify Unreal Engine's `Build.cs` files in CI?: Yes, Atlas is designed to understand and modify `Build.cs` files, correctly adding module dependencies using Unreal Build Tool rules before adding corresponding `#include` directives in C++ source.
How does Atlas handle permissions for tools like `bash` or `edit` in a headless Unreal Engine CI run?: In a headless CI run, all necessary tools (e.g., `bash`, `read`, `edit`) must be pre-approved in Atlas's permission configuration. This bypasses interactive 'ask' prompts, ensuring the pipeline runs smoothly.
Does Atlas support Unreal Engine's `clang-format` for code style?: Yes, Atlas can apply the engine's `.clang-format` configuration after drafting code changes, ensuring all generated or modified Unreal Engine C++ code adheres to the Epic style guide.
Can Atlas generate and run Unreal Automation Framework tests?: Atlas can write Automation Spec tests and execute them through `UnrealEditor-Cmd`, leveraging the Unreal Automation Framework. This allows for automated test generation and validation within your CI pipeline.
How does Atlas index Unreal Engine C++ code for better understanding?: Atlas indexes Unreal Engine C++ code by AST declarations using tree-sitter, not blind line windows. This allows it to understand `UCLASS`, `UPROPERTY`, `UFUNCTION` macros and `Build.cs` dependencies for accurate code analysis and modification.
What happens if an Atlas session needs to be resumed in an Unreal Engine CI pipeline?: You can resume or fork a prior Atlas session using `atlas run --continue`, `--session`, or `--fork`. This allows a pipeline step to build on an earlier run or recover from an interruption, maintaining context.

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 Unreal Engine: Terminal-Native AI Coding for UCLASS and Build.cs in 2026

Atlas is a terminal-native AI coding agent for Unreal Engine C++ in 2026, where UCLASS macros, the reflection system, and Build.cs module rules are the real API.

Write Unit Tests for Untested Unreal Engine Code with Atlas in 2026

Learn how Atlas helps Unreal Engine developers in 2026 write unit tests for existing modules. Atlas integrates with Unreal Automation Framework, Build.cs, and clang-format.

Locate where a behavior is implemented in Unreal Engine with Atlas in 2026

Pinpoint Unreal Engine C++ behavior implementations with Atlas. Use semantic search, grep, and LSP tools to find exact files and symbols in your 2026 projects, integrating with Build.cs and clang-format.

Onboard to an Unfamiliar Unreal Engine Codebase with Atlas in 2026

Quickly build a working mental model of any Unreal Engine C++ repository in 2026 using Atlas. Leverage semantic search, project structure analysis, and LSP integration for rapid onboarding.

Run the test suite and triage the failures in Unreal Engine with Atlas in 2026

Run and triage Unreal Engine test suite failures with Atlas in 2026. Transform red output from Unreal Automation Framework into prioritized root causes, streamlining C++ development.

Extract a Shared Helper from Duplicated Code in Unreal Engine with Atlas in 2026

Refactor Unreal Engine C++ code in 2026 by extracting shared helpers from duplicated logic using Atlas. Find near-duplicates, create new modules, and apply changes with full diff review, all while integrating with

Trace a Runtime Bug from a Stack Trace in Unreal Engine with Atlas in 2026

Pinpoint the exact line of code responsible for a production runtime bug in Unreal Engine C++ using Atlas. Go from stack trace to fix without a debugger attached.

Browse this resource hub