# Run Atlas Headless in CI for Clojure Projects in 2026 > Clojure developers in 2026 can run Atlas headless in CI using `atlas run --format json` to get machine-readable output, integrating with `deps.edn` and `kaocha`. In 2026, Clojure developers can run Atlas headless in CI pipelines to automate code tasks and receive machine-readable output by invoking `atlas run` with `--format json`, integrating direct with `deps.edn` for dependency management, `kaocha` for testing, and `cljfmt` for consistent code formatting. ## Key takeaways - Atlas runs non-interactively in Clojure CI using `atlas run` for automated tasks. - Machine-readable output is available via `atlas run --format json` for programmatic parsing in Clojure pipelines. - Pre-approve Atlas tools like `bash`, `read`, `edit`, and `todowrite` in `atlas.toml` for headless Clojure operations. - Atlas understands Clojure projects through `deps.edn`, namespaces, and aliases, enabling intelligent code modifications. - Verify Atlas's Clojure code changes with `clojure -M:test` using `kaocha` and format with `cljfmt` within the CI pipeline. - Atlas provides unified diffs and git patch snapshots for every edit, allowing for review and rollback of Clojure code changes. ## How to Invoke Atlas Headless in a Clojure CI Pipeline Running Atlas non-interactively in a Clojure CI pipeline in 2026 involves a single `atlas run` command. This command's default mode sends one prompt, streams events to standard output, and exits when the session becomes idle, making it ideal for automated workflows. To execute Atlas headless within a Clojure CI environment, developers use the `atlas run` command. This command is specifically designed for non-interactive operation, allowing it to be integrated into automated scripts. The primary input is a prompt provided as an argument to `atlas run`. For instance, a Clojure developer might prompt Atlas to 'add a new `deftest` case to `test/my_app/core_test.clj` for the `my-function`.' Atlas will then process this prompt, stream its actions and outputs to stdout, and conclude the session once its tasks are complete and no further interaction is required. This enables a straightforward, fire-and-forget execution model suitable for continuous integration. ## Obtaining Machine-Readable Output from Atlas in Clojure CI For Clojure CI pipelines requiring structured data, Atlas offers a `--format json` flag to stream raw event data. This feature, available in 2026, ensures that subsequent pipeline steps can programmatically parse Atlas's output rather than relying on human-readable prose. When a Clojure CI pipeline needs to consume Atlas's output programmatically, the `--format json` flag is essential. Instead of human-readable text, `atlas run --format json` streams a sequence of JSON objects to standard output, each representing a distinct event in the Atlas session. This machine-readable format allows other tools or scripts in the CI pipeline to parse and react to Atlas's actions, such as proposed code changes, tool calls, or session status updates. For example, a Clojure script could parse this JSON stream to automatically approve certain types of changes or log specific events, ensuring tight integration with existing CI infrastructure that processes structured data. ## Configuring Atlas Permissions for Headless Clojure Operations In 2026, headless Atlas runs in Clojure CI require pre-approved tool permissions because there is no interactive user to respond to prompts. Permissions for tools like `bash`, `read`, `edit`, and `todowrite` must be explicitly configured to allow Atlas to operate without interruption. A critical aspect of running Atlas headless in a Clojure CI pipeline is managing tool permissions. Since a non-interactive session cannot prompt a user for approval, all necessary tool calls must be pre-approved in Atlas's configuration. This involves setting `allow`, `ask`, or `deny` rules for tools such as `bash` (for executing shell commands like `clojure -M:test`), `read` (for reading Clojure source files or `deps.edn`), `edit` (for modifying `.clj` files), and `todowrite` (for creating or updating files). Without explicit `allow` permissions for the tools Atlas needs to use, the headless session will halt when it encounters an `ask` or `deny` rule, preventing the completion of the CI job. This ensures that Atlas operates within defined safety boundaries even in an automated context. ## Integrating Atlas with Clojure's `deps.edn` and Toolchain Atlas is designed to understand Clojure projects driven by `deps.edn`, recognizing namespaces, aliases, and REPL-shaped code as core units of work. In 2026, Atlas leverages this understanding to propose relevant changes, such as adding `deftest` cases or applying `cljfmt`. Atlas deeply integrates with the Clojure ecosystem by reading and interpreting `deps.edn` files. This allows Atlas to understand project structure, dependencies, defined aliases, and even Integrant or Component system maps. When prompted to modify Clojure code, Atlas can intelligently propose changes that align with Clojure idioms, such as threading a pipeline with `->>` or adding new `deftest` cases within `test/` namespaces. After making modifications, Atlas can be instructed to run `clojure -M:test` with `kaocha` to verify the changes, ensuring that the automated edits do not introduce regressions. Furthermore, Atlas can apply `cljfmt` to maintain consistent code style, ensuring that any generated diff adheres to the project's formatting conventions before committing. ## Resuming and Forking Atlas Sessions in Clojure CI Workflows For complex Clojure CI jobs in 2026 that span multiple steps or require re-evaluation, Atlas supports resuming or forking prior sessions. The `--continue`, `--session`, and `--fork` flags enable a pipeline step to build upon or replay an earlier Atlas run, preserving context. In scenarios where a Clojure CI job involves multiple stages or requires debugging, Atlas provides mechanisms to manage session continuity. The `--continue` flag allows a new `atlas run` command to pick up exactly where a previous session left off, preserving the agent's state and context. Alternatively, `--session ` can be used to explicitly load a specific prior session, enabling a pipeline to re-run or inspect a particular Atlas execution. For branching workflows, the `--fork` flag creates a new session based on an existing one, allowing for parallel experimentation or alternative approaches without altering the original session's history. These capabilities are crucial for robust CI pipelines that might need to retry failed steps or explore different solutions for Clojure code issues. ## Reviewing and Approving Atlas Changes in Clojure CI Atlas prioritizes safety in Clojure CI by drafting a plan in a read-only agent and computing a unified diff for every file edit. In 2026, these features allow for programmatic review and approval of changes before they are written to Clojure source files. Even in a headless CI environment, Atlas maintains a strong focus on safety and reviewability. Before making any modifications, Atlas drafts a plan within a read-only plan agent, which can be reviewed (if `--format json` is used to stream events). Once Atlas transitions to a build agent and proposes edits, it computes a unified diff for every file change. This diff is surfaced in the event stream, allowing the Clojure CI pipeline to programmatically inspect the proposed modifications. A subsequent pipeline step can then decide whether to approve these changes, potentially by checking them against `kaocha` test results or `cljfmt` output, before Atlas is allowed to write them to the filesystem or stage them for a git commit. Atlas also snapshots file changes as git patches, providing a robust rollback mechanism if an automated change needs to be reverted. ## Steps 1. 1: Define explicit tool permissions for Atlas in your project's `atlas.toml` configuration, ensuring `bash`, `read`, `edit`, and `todowrite` are set to `allow` for headless operations in your Clojure CI. 2. 2: Invoke `atlas run` in your CI script with a specific prompt and the `--format json` flag, for example: `atlas run --format json 'Add a new test case to test/my_app/core_test.clj for the function my-app.core/my-function.'` 3. 3: Explicitly set the model and provider using the `provider/model` form, such as `--model github/copilot-gpt4`, as required for headless execution in 2026. 4. 4: Allow Atlas to read your Clojure project's `deps.edn` file, namespace requires, and any defined `:aliases` to understand the project context and structure. 5. 5: Parse the JSON event stream output from `atlas run` in a subsequent CI step to inspect Atlas's plan, proposed edits (unified diffs), and tool calls. 6. 6: If Atlas proposes code changes, such as adding `deftest` cases under `test/`, review the generated diff from the JSON stream. 7. 7: Instruct Atlas to run `clojure -M:test` with `kaocha` to verify the proposed changes, ensuring tests pass before committing. This step requires `bash` tool permission. 8. 8: Have Atlas apply `cljfmt` to any modified Clojure files to ensure formatting conventions are maintained, then review the `cljfmt` diff. 9. 9: Use `atlas run --continue` or `--session ` in a later CI step if the job needs to build on or re-evaluate a previous Atlas session, preserving context. ## FAQ ### How does Atlas integrate with Clojure's `deps.edn` in CI? Atlas reads your Clojure project's `deps.edn` file to understand dependencies, aliases, and project structure. This context allows Atlas to propose relevant code changes and execute commands like `clojure -M:test` correctly within your CI pipeline. ### Can Atlas run `kaocha` tests in a headless Clojure CI pipeline? Yes, Atlas can run `kaocha` tests in a headless Clojure CI pipeline. You must grant Atlas `bash` tool permission, and then Atlas can execute `clojure -M:test` to run your `kaocha` test suite and report the results. ### What kind of output does `atlas run --format json` provide for Clojure projects? `atlas run --format json` streams raw JSON events to stdout, detailing Atlas's actions, plans, tool calls (like `bash` for `cljfmt`), and proposed file changes as unified diffs. This allows Clojure CI scripts to parse and react to Atlas's progress programmatically. ### How do I pre-approve Atlas tools for headless Clojure tasks? To pre-approve Atlas tools for headless Clojure tasks, configure your `atlas.toml` file. Set the permission rules for tools like `bash`, `read`, `edit`, and `todowrite` to `allow` so Atlas can operate without requiring interactive approval in your CI environment. ### Can Atlas apply `cljfmt` formatting automatically in a Clojure CI pipeline? Yes, Atlas can apply `cljfmt` formatting automatically. After making code changes, Atlas can be instructed to run `cljfmt` via a `bash` command, ensuring that all modifications adhere to your project's Clojure formatting conventions before being committed. ### How does Atlas handle code indexing for Clojure projects? Atlas indexes Clojure code by AST declarations using tree-sitter, not blind line windows. It can build its code index with local Ollama embeddings, keeping your Clojure code off third-party servers, and searches code with hybrid semantic and keyword retrieval. ### What safety features does Atlas offer for automated Clojure code changes? Atlas drafts a plan in a read-only agent and computes a unified diff for every file edit, surfacing it for approval. It also snapshots file changes as git patches, allowing for diffing and rolling back edits to your Clojure codebase, even in headless CI. --- Canonical HTML: https://runatlas.sh/resources/stacks/run-atlas-headless-in-ci-in-clojure Source of truth: aeo_pages row `/resources/stacks/run-atlas-headless-in-ci-in-clojure` (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.