How do I run Atlas non-interactively in a TensorFlow CI pipeline?

To run Atlas non-interactively in a TensorFlow CI pipeline, use the `atlas run` command. Its default mode is non-interactive, sending a single prompt and exiting when the session is idle. For machine-readable output, always include the `--format json` flag.

What output format does Atlas provide for automated TensorFlow tasks?

Atlas provides a raw event stream in JSON format when `atlas run` is invoked with the `--format json` flag. This allows subsequent pipeline steps to parse and act upon Atlas's actions, plans, and proposed changes to your TensorFlow codebase.

How does Atlas handle permissions for tools like `pytest` in a headless TensorFlow environment?

In a headless TensorFlow environment, Atlas requires pre-approved permissions for tools. You must configure `allow` rules for tools like `bash` (to run `pytest`), `read`, `edit`, and `todowrite` to ensure Atlas can execute actions without requiring interactive prompts.

Can Atlas optimize `tf.function` or `tf.data` pipelines in CI?

Yes, Atlas can optimize `tf.function` or `tf.data` pipelines in CI. You can prompt Atlas to wrap hot Python loops in `tf.function` or add `tf.data` prefetch and cache stages, then measure performance, all within an automated headless run.

How does Atlas ensure code privacy when indexing TensorFlow projects?

Atlas ensures code privacy by building its code index with local Ollama embeddings. This means your TensorFlow code, including `tf.keras` model definitions, remains on your local infrastructure and is not sent to third-party servers for indexing or analysis.

What TensorFlow-specific tools does Atlas integrate with?

Atlas integrates with core TensorFlow development tools such as `pytest` for testing, `uv` for package management, and `black` for code formatting. It understands `pyproject.toml` configurations and can read `tf.keras` model definitions and `tf.data` pipelines.

How can I resume a failed Atlas session in a TensorFlow CI job?

You can resume a failed Atlas session in a TensorFlow CI job using the `--continue` or `--session ` flags with `atlas run`. This allows you to pick up from where a previous run left off, saving time and resources on iterative TensorFlow development tasks.

Run Atlas Headless in CI with TensorFlow in 2026

To run an Atlas session non-interactively in a TensorFlow CI pipeline and get machine-readable output, invoke `atlas run` with the `--format json` flag. This allows your pipeline to parse the event stream, integrating Atlas's capabilities like wrapping hot Python loops in `tf.function` or adding `tf.data` prefetch stages directly into your `pytest` test suite or `uv` managed environment, ensuring robust automation for TensorFlow projects.

How to Run Atlas Headless for TensorFlow CI Automation

In 2026, TensorFlow developers can automate complex tasks like `tf.function` optimization or `tf.data` pipeline enhancements directly within CI by running Atlas headless. The `atlas run` command, specifically designed for non-interactive execution, sends a single prompt, streams events to stdout, and exits when the session goes idle, making it ideal for automated TensorFlow workflows.

Running Atlas headless in a TensorFlow CI pipeline is achieved by invoking `atlas run` with your desired prompt. For machine-readable output that a subsequent pipeline step can parse, always include the `--format json` flag. This streams raw event data, rather than prose, allowing for programmatic analysis of Atlas's actions and outputs. For instance, you might prompt Atlas to 'wrap a hot Python loop in tf.function and explain the retracing warnings it removes' or 'add tf.data prefetch and cache stages, then measure the step time before and after'. The default non-interactive mode ensures Atlas processes the prompt and exits, providing a clean, automated experience for TensorFlow development and deployment.

Configuring Permissions for Headless TensorFlow Workflows

For a headless Atlas run in a TensorFlow CI pipeline, pre-approving tools is critical to avoid interactive prompts. Atlas requires explicit permission rules for tools like `bash`, `read`, `edit`, and `todowrite` before execution, ensuring your 2026 CI/CD pipeline operates without interruption when modifying `tf.keras` models or `tf.data` pipelines.

When Atlas operates in a headless CI environment, there is no user to answer 'ask' prompts for tool execution. Therefore, it is essential to pre-approve the tools Atlas needs through its permission configuration. This involves setting `allow`, `ask`, or `deny` rules for specific tools. For TensorFlow-related tasks, Atlas commonly uses tools such as `bash` for executing shell commands (e.g., running `pytest`), `read` for accessing code (like `tf.keras` model definitions or `tf.data` input pipelines), `edit` for modifying files (e.g., adding `tf.function` decorators), and `todowrite` for creating new files or updating existing ones. Explicitly allowing these tools in your Atlas configuration ensures that your automated TensorFlow workflows proceed without requiring manual intervention.

Integrating Atlas with TensorFlow's Native Toolchain

Integrating Atlas into a TensorFlow project's CI pipeline means leveraging existing tools like `pytest` for testing and `uv` for package management. Atlas can run `pytest` behind a permission prompt, for example, to validate changes to `tf.data` pipelines, ensuring code quality and performance in 2026, while `black` formats any generated diffs.

Atlas is designed to work direct within a TensorFlow developer's existing toolchain. This means interacting directly with familiar tools and file structures. For package management, Atlas expects a `pyproject.toml` file that pins `tensorflow` and `keras`, and it can leverage `uv` for dependency installation. When Atlas proposes code changes, such as adding `tf.data` prefetch stages, it can then be instructed to run `pytest` to validate the changes. Atlas can execute `pytest` behind a permission prompt, ensuring that tests for your `tf.keras` models or `tf.data` pipelines are run and their results are considered. Furthermore, Atlas can format the unified diffs it generates using `black`, adhering to your project's established code style for any modifications to TensorFlow code.

Managing Model Context and Output for TensorFlow Tasks

Atlas indexes TensorFlow code by AST declarations using tree-sitter, not blind line windows, providing a precise understanding of your `tf.keras` models and `tf.data` pipelines. This allows Atlas to build its code index with local Ollama embeddings, keeping sensitive TensorFlow code off third-party servers in 2026, a critical security feature for proprietary models.

Atlas's ability to understand and interact with TensorFlow code is rooted in its advanced indexing capabilities. It indexes code by AST (Abstract Syntax Tree) declarations using tree-sitter, which provides a much deeper and more accurate understanding of your `tf.keras` model definitions, `tf.data` input pipelines, and custom `training_step` overrides than simple line-based indexing. Crucially for TensorFlow projects, Atlas can build its code index with local Ollama embeddings, ensuring that your proprietary model architectures and training data remain entirely on your local infrastructure, never leaving your control or being exposed to third-party servers. Every Atlas tool call is permission-gated, and it drafts a plan in a read-only agent before executing, computing a unified diff for every file edit and surfacing it for approval, even in headless mode via the JSON output. Atlas also snapshots file changes as git patches, allowing edits to be easily diffed and rolled back if needed for your TensorFlow codebase.

Resuming and Forking Atlas Sessions in TensorFlow Pipelines

When a TensorFlow CI job needs to build on an earlier Atlas run, you can resume or fork a prior session using `--continue`, `--session`, or `--fork`. This capability is crucial for iterative development, allowing a pipeline step to replay or resume a complex `tf.function` optimization task from a previous 2026 run without starting from scratch, saving valuable compute resources.

Atlas provides robust mechanisms for managing session state, which is particularly useful in CI/CD pipelines for TensorFlow projects where tasks might be long-running or require multiple steps. If an Atlas session needs to be replayed, resumed, or built upon, you can use the `--continue`, `--session`, or `--fork` flags with `atlas run`. For example, if an initial Atlas run identified a `tf.data` pipeline bottleneck and proposed a solution, a subsequent CI step could resume that session to apply and validate the fix. The `--session` flag allows you to specify a particular session ID, while `--continue` will pick up the last active session. `--fork` creates a new session based on an existing one, allowing for parallel experimentation or alternative approaches to a TensorFlow optimization problem without altering the original session's state.

Step by step

01Ensure your TensorFlow project's `pyproject.toml` file explicitly pins `tensorflow` and `keras` versions for consistent environments.
02Install project dependencies using `uv install` to set up the Python environment for Atlas and TensorFlow.
03Configure Atlas permissions to `allow` necessary tools like `bash`, `read`, `edit`, and `todowrite` for headless operation in your TensorFlow CI.
04Invoke `atlas run --format json --prompt "Add tf.data prefetch and cache stages to my input pipeline in `data_loader.py` and measure step time before and after."` to automate TensorFlow pipeline optimization.
05Parse the JSON event stream output from `atlas run` in a subsequent CI pipeline step to programmatically analyze Atlas's actions and proposed TensorFlow code changes.
06Optionally, include a step to have Atlas run `pytest` behind a permission prompt to validate changes to your `tf.keras` models or `tf.data` pipelines, and format any generated diffs with `black`.
07For iterative development, use `atlas run --continue` or `atlas run --session <session_id>` to resume a prior Atlas session and build upon previous TensorFlow-related work.

Frequently asked questions

How do I run Atlas non-interactively in a TensorFlow CI pipeline?: To run Atlas non-interactively in a TensorFlow CI pipeline, use the `atlas run` command. Its default mode is non-interactive, sending a single prompt and exiting when the session is idle. For machine-readable output, always include the `--format json` flag.
What output format does Atlas provide for automated TensorFlow tasks?: Atlas provides a raw event stream in JSON format when `atlas run` is invoked with the `--format json` flag. This allows subsequent pipeline steps to parse and act upon Atlas's actions, plans, and proposed changes to your TensorFlow codebase.
How does Atlas handle permissions for tools like `pytest` in a headless TensorFlow environment?: In a headless TensorFlow environment, Atlas requires pre-approved permissions for tools. You must configure `allow` rules for tools like `bash` (to run `pytest`), `read`, `edit`, and `todowrite` to ensure Atlas can execute actions without requiring interactive prompts.
Can Atlas optimize `tf.function` or `tf.data` pipelines in CI?: Yes, Atlas can optimize `tf.function` or `tf.data` pipelines in CI. You can prompt Atlas to wrap hot Python loops in `tf.function` or add `tf.data` prefetch and cache stages, then measure performance, all within an automated headless run.
How does Atlas ensure code privacy when indexing TensorFlow projects?: Atlas ensures code privacy by building its code index with local Ollama embeddings. This means your TensorFlow code, including `tf.keras` model definitions, remains on your local infrastructure and is not sent to third-party servers for indexing or analysis.
What TensorFlow-specific tools does Atlas integrate with?: Atlas integrates with core TensorFlow development tools such as `pytest` for testing, `uv` for package management, and `black` for code formatting. It understands `pyproject.toml` configurations and can read `tf.keras` model definitions and `tf.data` pipelines.
How can I resume a failed Atlas session in a TensorFlow CI job?: You can resume a failed Atlas session in a TensorFlow CI job using the `--continue` or `--session <session_id>` flags with `atlas run`. This allows you to pick up from where a previous run left off, saving time and resources on iterative TensorFlow development tasks.

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 TensorFlow: Terminal-Native AI Coding for Keras 3 and tf.data in 2026

Atlas is a terminal-native AI coding agent for TensorFlow and Keras 3 in 2026, where tf.function graph tracing and tf.data pipelines are what make training fast.

Write Unit Tests for Untested Code in TensorFlow with Atlas in 2026

Streamline writing unit tests for TensorFlow modules with Atlas. Learn how Atlas uses `pytest`, `uv`, and `black` to add robust tests, matching your repo's conventions in 2026.

Upgrade a Dependency and Fix Breakage in TensorFlow with Atlas in 2026

TensorFlow developers in 2026 can use Atlas to upgrade dependencies like Keras 3, automatically fixing compile and test failures. Atlas drives uv for package management, reads pytest output, and formats with black.

Rename a symbol across the repo in TensorFlow with Atlas in 2026

In 2026, Atlas empowers TensorFlow developers to accurately rename functions, classes, or constants across their entire codebase, leveraging LSP, grep, and robust safety features. Ensure your Keras 3 models and tf.data

Migrate a Deprecated API Across Every Callsite in TensorFlow with Atlas in 2026

Efficiently migrate deprecated TensorFlow APIs across your entire codebase with Atlas. Leverage `lsp`, `todowrite`, and `apply_patch` for a complete, verified transition in 2026.

Plan a multi-file change before editing in TensorFlow with Atlas in 2026

Design and review multi-file TensorFlow changes with Atlas in 2026. Atlas's plan agent ensures no code is modified until your design is approved, integrating with pytest, uv, and black for a safe workflow.

Diagnose a Hanging or Long-Running Command in TensorFlow with Atlas in 2026

TensorFlow developers in 2026 can use Atlas to diagnose whether a build or script is genuinely slow or silently blocked on input, getting it unstuck quickly.

Browse this resource hub