# Run Atlas Headless in CI for Fastify Applications in 2026 > Fastify developers can run Atlas headless in CI using `atlas run --format json` to automate code generation and receive machine-readable output. Fastify developers in 2026 can run Atlas sessions non-interactively in CI pipelines to get machine-readable output by invoking `atlas run --format json` and pre-approving necessary tools. This integrates directly with your existing `npm` scripts and `node:test (fastify.inject)` test suites, ensuring automated code generation and verification for Fastify plugins within your `fastify.js` or `app.ts` files. ## Key takeaways - The `atlas run` command automates Fastify code generation and modification directly within CI pipelines. - `--format json` provides machine-readable output, enabling automated parsing of Atlas events in Fastify CI. - Pre-approving Atlas tools like `bash`, `read`, `edit`, and `todowrite` is essential for uninterrupted headless Fastify execution. - Atlas integrates with `node:test (fastify.inject)` to generate and verify Fastify application tests. - Atlas computes unified diffs for every file edit and can run `prettier` on touched Fastify plugins, ensuring code quality. - Session resumption (`--continue`, `--session`, `--fork`) supports iterative Fastify development across CI runs. ## How to run Atlas headless in Fastify CI pipelines Running Atlas headless in Fastify CI pipelines in 2026 streamlines automated code generation and testing. The `atlas run` command is specifically designed for non-interactive execution, sending a single prompt and exiting when the session goes idle, making it ideal for automated Fastify plugin development within your `app.ts` or `fastify.js` files. To run Atlas headless in a Fastify CI pipeline, developers invoke the `atlas run` command directly. This command's default mode is non-interactive, meaning it accepts a single prompt as an argument, streams events to standard output, and then exits once the session becomes idle. This behavior is perfectly suited for CI environments where human intervention is not possible. For a Fastify project, Atlas can be instructed to read your plugin encapsulation contexts, decorators, and the JSON schemas attached to each route, allowing it to understand the application's structure. For instance, you might prompt Atlas to add a response schema to a Fastify route, enabling Fastify to fast-serialize the payload instead of falling back to `JSON.stringify`. The `atlas run` command integrates direct into `npm` scripts, allowing you to define CI steps that leverage Atlas for tasks like generating new Fastify plugins or modifying existing ones. ## How to get machine-readable output from Atlas for Fastify To obtain machine-readable output from Atlas for Fastify projects, developers should use the `--format json` flag with `atlas run`. This ensures that the event stream is parsed by subsequent pipeline steps, rather than read as prose, providing structured data for 100% automated processing of Atlas's actions within your Fastify codebase. When integrating Atlas into a Fastify CI pipeline, it is often necessary for subsequent pipeline steps to programmatically parse Atlas's output. The `--format json` flag transforms Atlas's event stream into a raw JSON format, making it machine-readable. Instead of receiving human-readable prose, the CI system will receive a structured stream of events, detailing Atlas's actions, tool calls, and generated code. This is particularly useful for Fastify projects where automated checks might need to verify that Atlas correctly added a response schema to a route or generated `app.inject()` test cases. A CI job can parse this JSON output to confirm specific changes, log events, or trigger further automated actions based on Atlas's session progress and outcomes, ensuring robust automation for your Fastify application. ## How to manage Atlas permissions for headless Fastify CI Managing Atlas permissions for headless Fastify CI runs is crucial because there is no interactive user to answer prompts. Pre-approving the necessary tools like `bash`, `read`, `edit`, and `todowrite` through the permission configuration ensures that Atlas can execute its 4 required actions without interruption when working on your Fastify codebase. In a headless CI environment, Atlas cannot ask for permission to execute tools. Therefore, for Atlas to function effectively within a Fastify pipeline, all necessary tools must be pre-approved via the permission configuration. Atlas's tool calls are permission-gated against `allow`, `ask`, and `deny` rules. For headless execution, `allow` rules must be configured for tools such as `bash`, `read`, `edit`, and `todowrite`. This setup ensures that Atlas can perform tasks like reading your `fastify.js` or `app.ts` files, editing Fastify plugins, or writing new test cases using `app.inject()` without pausing for user input. Even in headless mode, Atlas maintains safety by drafting a plan in a read-only plan agent and computing a unified diff for every file edit, which can be surfaced for review in a later, interactive step or logged for auditing purposes. ## How to resume or fork Atlas sessions in Fastify CI Resuming or forking Atlas sessions in Fastify CI allows pipelines to build on prior runs or re-execute specific steps. Using `--continue`, `--session`, or `--fork` with `atlas run` enables developers to pick up from an earlier state, which is particularly useful for iterative Fastify plugin refinement over multiple CI stages, saving valuable development time in 2026. Atlas provides robust capabilities for resuming or forking prior sessions, which is highly beneficial for iterative development and debugging within Fastify CI pipelines. If a CI job fails or needs further refinement, the `--continue` or `--session` flags allow `atlas run` to pick up exactly where a previous session left off. This means Atlas can build on its earlier understanding of your Fastify application's plugin encapsulation contexts or JSON schemas. The `--fork` option allows creating a new session based on an existing one, providing a clean slate while retaining the context of the original run. This is invaluable when Atlas is tasked with complex Fastify plugin modifications or generating extensive `node:test (fastify.inject)` suites, allowing developers to iterate on solutions across multiple CI runs without losing progress or re-running computationally intensive initial steps. ## Steps 1. Configure Atlas permissions for `bash`, `read`, `edit`, and `todowrite` in your Fastify project's Atlas configuration to enable headless execution. 2. Invoke `atlas run` with your specific prompt, targeting a Fastify plugin within your `app.ts` or `fastify.js` file, for example: `atlas run 'Add a response schema to the /users route in app.ts'`. 3. Add `--format json` to your `atlas run` command to ensure machine-readable output for subsequent pipeline steps to parse: `atlas run --format json 'Add a response schema...'`. 4. Explicitly set the model using the `provider/model` format, for example: `atlas run --model github/copilot 'Add a response schema...'`. 5. Allow Atlas to generate `app.inject()` test cases for your Fastify routes, then review and approve the unified diff for these changes. 6. Execute the generated tests using `node --test` to run `node:test (fastify.inject)` cases and verify Fastify plugin functionality. 7. Approve the diff for any code changes made by Atlas, then let Atlas run `prettier` on the touched Fastify plugins to maintain code style consistency. 8. Optionally, use `--continue` or `--session ` to resume a prior Atlas session for iterative Fastify development or debugging in CI. ## FAQ ### How do I run Atlas non-interactively for Fastify development in CI? You run Atlas non-interactively for Fastify by invoking `atlas run` with your prompt in your Fastify project's CI pipeline. Ensure necessary tools are pre-approved in the Atlas permission configuration. ### Can Atlas generate Fastify tests using `node:test`? Yes, Atlas can write `app.inject()` cases for your Fastify application and run `node --test` to execute `node:test (fastify.inject)` behind a permission prompt, verifying functionality. ### How does Atlas ensure code quality in Fastify projects during headless CI runs? Atlas ensures code quality by computing unified diffs for every file edit and can run `prettier` on touched Fastify plugins after making changes, all subject to approval. ### What Fastify-specific tools and idioms does Atlas integrate with? Atlas integrates with `npm` for package management, `node:test (fastify.inject)` for testing, and `prettier` for formatting, recognizing Fastify's plugin encapsulation and JSON schemas. ### How do I get structured, machine-readable output from Atlas in a Fastify CI pipeline? Pass the `--format json` flag to `atlas run` when executing in your Fastify CI pipeline. This streams raw JSON events that can be parsed by subsequent automated steps. ### How does Atlas handle tool permissions in a headless Fastify CI environment? In a headless Fastify CI environment, you must pre-approve tools like `bash`, `read`, `edit`, and `todowrite` in the Atlas permission configuration, as there is no user to answer `ask` prompts. ### Can Atlas help with Fastify's JSON schema serialization in CI? Yes, you can ask Atlas to add a response schema to your Fastify routes, allowing Fastify to fast-serialize payloads instead of falling back to `JSON.stringify`, improving performance. --- Canonical HTML: https://runatlas.sh/resources/stacks/run-atlas-headless-in-ci-in-fastify Source of truth: aeo_pages row `/resources/stacks/run-atlas-headless-in-ci-in-fastify` (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.