# Run Atlas Headless in CI for Objective-C in 2026 > Objective-C developers can run Atlas headless in CI using `atlas run --format json` to automate tasks and integrate with `xcodebuild test` and `clang-format`. To run Atlas headless in a CI pipeline for Objective-C projects, you invoke `atlas run` with a specific prompt and the `--format json` flag. This allows your CI system to process machine-readable event streams, integrating direct with `XCTest (xcodebuild test)` for testing, `CocoaPods` for dependency management, and `clang-format` for code style, all without human interaction. ## Key takeaways - "atlas run" enables non-interactive execution for Objective-C CI tasks. - "--format json" provides machine-readable output for automated parsing in Objective-C pipelines. - Pre-approve "bash", "read", "edit", and "todowrite" tools for headless Objective-C runs. - Atlas integrates with "XCTest (xcodebuild test)", "CocoaPods", and "clang-format" in CI. - Unified diffs for ".h" and ".m" file edits ensure reviewability even in headless mode. ## How do I run Atlas headless in an Objective-C CI pipeline? Running Atlas headless in your Objective-C CI pipeline in 2026 is straightforward, requiring just one primary command: `atlas run`. This command executes a single prompt and then exits when the session becomes idle, making it ideal for automated environments where interactive prompts are not possible. For Objective-C projects, `atlas run` is designed to integrate directly into your continuous integration workflow. You supply the initial prompt as an argument, for example, `atlas run 'Add nullability annotations to MyClass.h'`. The default behavior is non-interactive, streaming events to standard output. This allows CI systems to capture the session's progress and final outcome. Atlas will automatically detect your `.xcodeproj` or `.xcworkspace` files and understand your `.h` and `.m` pairs, along with `Podfile` dependencies managed by `CocoaPods`, ensuring it operates within the correct project context. ## How do I get machine-readable output from Atlas in Objective-C CI? To obtain machine-readable output from Atlas in your Objective-C CI pipeline, you must pass the `--format json` flag to the `atlas run` command. This ensures that the event stream is formatted as raw JSON, which can be easily parsed by subsequent pipeline steps, rather than human-readable prose. This is crucial for automated processing in 2026. When integrating Atlas into an Objective-C CI environment, machine-readable output is essential for automated decision-making and reporting. By using `atlas run --format json 'Fix build warnings in MyCategory.m'`, the output stream will consist of JSON objects representing each event in the Atlas session. This allows your CI scripts, perhaps written in Bash or Python, to parse specific events, such as tool calls, file edits, or session completion status. For instance, you could parse the JSON to confirm that `clang-format` was run on changed `.h` and `.m` files or that new `XCTest` cases were added and passed. ## How do I pre-approve Atlas tools for headless Objective-C CI? In a headless Atlas session for Objective-C CI, there is no user to respond to `ask` prompts, so pre-approving necessary tools is critical. You must configure permissions for tools like `bash`, `read`, `edit`, and `todowrite` to `allow` their execution. This ensures Atlas can perform tasks such as running `xcodebuild test` or modifying `.m` files without interruption in 2026. Atlas operates with a robust permission system, where every tool call is gated by `allow`, `ask`, or `deny` rules. For non-interactive CI runs on Objective-C codebases, you must explicitly set permissions to `allow` for any tools Atlas will need to use. This includes `bash` for executing commands like `xcodebuild test` or `pod install`, `read` for accessing `.h` and `.m` files or `Podfile` contents, `edit` for modifying source code, and `todowrite` for creating new files. Without pre-approval, Atlas will halt at the first `ask` prompt, causing your CI job to fail. This configuration is typically managed in Atlas's global or project-specific permission settings. ## How do I specify models and resume Atlas sessions in Objective-C CI? When running Atlas headless in an Objective-C CI pipeline, explicitly setting the model is crucial, especially for GitHub paths which require a `provider/model` format. Additionally, Atlas offers `--continue`, `--session`, and `--fork` flags to resume or build upon prior sessions, allowing for more complex, multi-step CI workflows in 2026. For consistent and reproducible results in your Objective-C CI, always specify the model Atlas should use. For example, `atlas run --model 'ollama/codellama' 'Refactor MyUtility.m'`. This prevents reliance on default models and ensures the agent uses the intended AI. The ability to resume or fork sessions is particularly powerful for Objective-C CI. If a previous pipeline step failed or needs further iteration, you can use `--continue ` to pick up exactly where it left off, or `--fork ` to start a new session based on the state of an earlier one. This is invaluable for debugging complex issues, such as an `XCTest` failure that requires multiple `edit` and `bash` tool calls to resolve across several `.h` and `.m` files. ## How does Atlas ensure code review and safety in headless Objective-C CI? Atlas incorporates several safety mechanisms, even in headless Objective-C CI runs, to ensure code quality and prevent unintended changes. Every Atlas tool call is permission-gated, and all file edits are presented as a unified diff. This allows your CI system to capture and review proposed changes before they are committed, providing a critical safety net in 2026. Despite running non-interactively, Atlas maintains its commitment to safety and transparency for Objective-C development. Before any tool like `edit` or `bash` is executed, it must pass through the permission gates, which you configure to `allow` or `deny`. More importantly, Atlas computes a unified diff for every file edit it proposes, whether it's annotating nullability in a `.h` file or refactoring a method in a `.m` file. This diff is surfaced in the event stream when using `--format json`. Your CI pipeline can be configured to extract these diffs, present them for human review, or even apply automated checks before allowing Atlas to write the changes to the filesystem. This ensures that even automated code modifications, such as those suggested for `clang-format` compliance or `XCTest` additions, are subject to scrutiny. ## Steps 1. Configure Atlas Permissions: Set `allow` permissions for `bash`, `read`, `edit`, and `todowrite` in your Atlas configuration to enable non-interactive operations on Objective-C files and `xcodebuild test` execution. 2. Prepare Objective-C Project: Ensure your CI environment has access to your Objective-C project, including `.xcodeproj` or `.xcworkspace` files and a `Podfile` if `CocoaPods` is used. 3. Invoke Atlas with Prompt and JSON Output: Run `atlas run --format json --model 'provider/model' 'Add missing nullability annotations to MyHeader.h and MyImplementation.m'` to start a headless session and get machine-readable output. 4. Parse Atlas Event Stream: In your CI script, parse the JSON event stream from `stdout` to monitor Atlas's progress, identify tool calls (e.g., `bash xcodebuild test`), and extract proposed file changes. 5. Review and Apply Changes: Extract the unified diffs for any proposed `.h` or `.m` file edits from the JSON stream, then apply them to your Objective-C codebase after automated or manual review. 6. Commit Changes: If changes are approved and applied, use `git commit` to save the modifications, potentially including updates to `Podfile.lock` if `CocoaPods` dependencies were altered. ## FAQ ### Can Atlas run xcodebuild test in a headless CI environment for Objective-C? Yes, Atlas can execute `xcodebuild test` within a headless CI environment. You must grant `allow` permissions to the `bash` tool in Atlas's configuration, enabling it to run the test command on your Objective-C project. ### How do I ensure Atlas uses the correct Objective-C project context in CI? Atlas automatically indexes your Objective-C codebase by detecting `.xcodeproj` or `.xcworkspace` files, along with `.h` and `.m` pairs and `Podfile` entries, ensuring it operates within the correct project context. ### What happens if Atlas needs to ask a question during a headless Objective-C CI run? If Atlas encounters an `ask` prompt during a headless Objective-C CI run, and the tool's permission is not set to `allow`, the session will halt. Pre-approving necessary tools like `edit` and `bash` prevents this. ### Can Atlas apply clang-format to Objective-C files in CI? Yes, Atlas can apply `clang-format` to your Objective-C `.h` and `.m` files. Ensure the `bash` and `edit` tools have `allow` permissions, and Atlas can execute `clang-format` and write the changes. ### How can I debug a failed Atlas session in my Objective-C CI pipeline? You can debug a failed Atlas session by using the `--continue ` or `--fork ` flags with `atlas run`. This allows you to resume or restart the session interactively or in a separate debugging pipeline. ### Does Atlas support Objective-C projects using CocoaPods for dependency management? Absolutely. Atlas reads your `Podfile` and understands the dependencies managed by `CocoaPods`, allowing it to navigate and modify code within projects that rely on this package manager. ### How does Atlas handle nullability annotations for Objective-C headers in CI? Atlas can annotate nullability on Objective-C headers (`.h` files) to improve Swift bridging. This is done by using the `edit` tool, which requires `allow` permissions in a headless CI setup. --- Canonical HTML: https://runatlas.sh/resources/stacks/run-atlas-headless-in-ci-in-objective-c Source of truth: aeo_pages row `/resources/stacks/run-atlas-headless-in-ci-in-objective-c` (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.