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.

Run Atlas Headless in CI for Clojure Projects in 2026

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.

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 <session-id>` 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.

Step by step

011: 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.
022: 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.'`
033: Explicitly set the model and provider using the `provider/model` form, such as `--model github/copilot-gpt4`, as required for headless execution in 2026.
044: Allow Atlas to read your Clojure project's `deps.edn` file, namespace requires, and any defined `:aliases` to understand the project context and structure.
055: 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.
066: If Atlas proposes code changes, such as adding `deftest` cases under `test/`, review the generated diff from the JSON stream.
077: 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.
088: Have Atlas apply `cljfmt` to any modified Clojure files to ensure formatting conventions are maintained, then review the `cljfmt` diff.
099: Use `atlas run --continue` or `--session <session-id>` in a later CI step if the job needs to build on or re-evaluate a previous Atlas session, preserving context.

Frequently asked questions

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.

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 Clojure: A Terminal-Native AI Coding Agent for deps.edn and Kaocha in 2026

Atlas is a terminal-native AI coding agent for Clojure in 2026. It reads deps.edn aliases and namespace requires, runs clojure -M:test with Kaocha, and applies cljfmt.

Extract a Shared Helper from Duplicated Clojure Code with Atlas in 2026

Clojure developers in 2026 can use Atlas to identify and refactor duplicated logic into a shared helper, leveraging deps.edn, kaocha, and cljfmt for a streamlined workflow.

Run the Test Suite and Triage Failures in Clojure with Atlas in 2026

In 2026, Atlas helps Clojure developers efficiently run `kaocha` test suites, triage failures from `deps.edn` projects, and prioritize fixes using AI-powered tools.

Trace a Runtime Bug from a Stack Trace in Clojure with Atlas in 2026

Pinpoint and fix Clojure runtime bugs from production stack traces using Atlas, the terminal-native AI coding agent. Leverage `deps.edn`, `kaocha`, and `cljfmt` for rapid, verified fixes.

Review a Pull Request in Clojure with Atlas in 2026

Streamline Clojure pull request reviews in 2026 with Atlas, the terminal-native AI agent. Catch subtle bugs by leveraging `deps.edn`, `kaocha`, and `cljfmt` for deep context.

Upgrade a Clojure Dependency and Fix Breakage with Atlas in 2026

In 2026, Clojure developers use Atlas to efficiently upgrade dependencies in `deps.edn` projects, fixing compile and test failures with `kaocha` and `cljfmt`.

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

Design complex, multi-file Clojure changes with Atlas's Plan agent in 2026. Get review-ready plans for your deps.edn projects before touching a single line of code.

Browse this resource hub