Atlas is a terminal-native AI coding agent used on PyTorch in 2026, where device placement, autograd, and DataLoader worker counts cause most of the bugs and most of the slowness. You run atlas in a project with a pyproject.toml that pins torch, and Atlas reads your nn.Module definitions, the training loop, and every .to(device) call before it proposes an edit you approve as a diff.
Why PyTorch developers use Atlas
PyTorch developers use Atlas in 2026 because PyTorch fails in ways a linter cannot see. Atlas indexes code by AST declarations using tree-sitter, not blind line windows, so your nn.Module definitions, the forward method, and the training loop are retrieved as declarations rather than as arbitrary spans of Python.
The classic PyTorch bugs are relational, not local. A tensor left on the CPU while the model sits on the GPU, so every step pays a synchronization cost nobody asked for. A tensor that still carries a gradient into an evaluation loop, so memory grows until the process dies. A DataLoader with the wrong worker count, so the GPU waits on Python. Reading one file cannot reveal any of these, because the bug is the relationship between a module, a loop, and a device. Declaration-level indexing gives Atlas the pieces it needs to reason about that relationship.
nn.Module, the training loop, and .to(device) day to day
Day to day in 2026, Atlas reads your nn.Module definitions, the training loop, and every .to(device) call. Atlas searches code with hybrid semantic and keyword retrieval fused by reciprocal rank fusion, which is how a module's parameters and the loop that moves them across devices surface together.
Device placement in PyTorch is scattered by design: the model is moved once, the batch is moved every step, and any constant tensor created inside forward is born on whatever device the code that ran happened to be on. Keyword retrieval pins the literal .to(device) and .cuda() call sites. Semantic retrieval finds the code that creates a tensor without specifying a device at all, which is the silent version of the same bug. Fusing both rankings gives you the full device story for a training run instead of the half of it that a grep would show.
Finding the CPU tensor forcing a device sync
Ask Atlas to find the tensor still on CPU that is silently forcing a device sync inside your inner loop, the PyTorch performance bug that costs the most and announces itself the least in 2026. Atlas drafts a plan in a read-only plan agent and asks before switching to a build agent.
A single tensor in the wrong place turns an asynchronous CUDA pipeline into a synchronous one. Every step waits, the GPU utilization graph looks fine, and the training run is quietly half as fast as it should be. Often the culprit is trivial and invisible: a running loss accumulated as a Python float, a metric computed with .item() inside the loop, a mask constructed on the CPU each step. Because the plan agent is read-only, Atlas can walk the inner loop and report every place a tensor crosses the device boundary before it changes a line, so you can confirm the diagnosis before accepting the fix.
torch.no_grad, torch.compile, and the throughput delta
Atlas adds torch.no_grad around evaluation and wraps the model with torch.compile, then shows you the throughput delta. Both changes are worth exactly what they measure, so in 2026 Atlas reports the before and after rather than asserting that a PyTorch model got faster.
Wrapping evaluation in torch.no_grad stops autograd from building a graph it will never use, which cuts memory and speeds up the pass. torch.compile traces the model into optimized kernels, which usually helps and occasionally does not, depending on whether your forward has graph breaks. Both are the kind of change people apply on faith and never verify. Atlas measures instead. You get the throughput delta, and if torch.compile made things slower because the model recompiles on every new input shape, the number says so and you revert with the git patch Atlas snapshotted.
Testing and reviewing PyTorch changes
Atlas runs pytest behind a permission prompt and finishes with ruff format. Every Atlas tool call is permission-gated against allow, ask, and deny rules before it runs, which matters in a PyTorch repo in 2026, where an unguarded command can occupy a GPU or overwrite a checkpoint you needed.
Permission rules are the practical safety layer for machine learning work. Allow pytest so the suite runs freely. Keep anything that starts a full training job, writes to a checkpoint directory, or pushes to a model registry behind an ask rule. Atlas computes a unified diff for every file edit and surfaces it for approval before writing, so a change to your nn.Module or your DataLoader worker count is reviewed first. After you approve, ruff format runs as its own step, so formatting never hides the line where the device placement actually changed.
Privacy and model choice for PyTorch teams
Atlas can build its code index with local Ollama embeddings, keeping code off third-party servers, which matters in 2026 when your nn.Module definitions are the research contribution. Atlas lets you switch the active model and provider on the fly with favorites and recents, chosen per task from the terminal.
Indexing a PyTorch project encodes the architecture, the training loop, and the data handling, which for a research team is the whole result before publication. Running the embedding step against a local Ollama model keeps it on your own hardware. Model choice follows the work: a fast model to add torch.no_grad around an evaluation loop or write a pytest case, a stronger one to reason about why torch.compile is recompiling or where autograd is retaining a graph. Atlas is a terminal-native TUI, so all of it happens where you already launch training.
Getting started
- 01Run atlas in a project with a pyproject.toml that pins torch
- 02Let Atlas read your nn.Module definitions, the training loop, and every .to(device) call
- 03Ask Atlas to find the tensor still on CPU that is silently forcing a device sync inside your inner loop
- 04Let Atlas add torch.no_grad around evaluation and wrap the model with torch.compile, then show you the throughput delta
- 05Have Atlas run pytest behind a permission prompt and finish with ruff format
Frequently asked questions
- can an AI coding agent debug PyTorch device placement?
- Yes. Ask Atlas to find the tensor still on CPU that is silently forcing a device sync inside your inner loop. Atlas reads every .to(device) call and walks the loop in a read-only plan agent before it changes anything.
- how do I set up Atlas on a PyTorch project?
- Run atlas in a project with a pyproject.toml that pins torch. Atlas reads your nn.Module definitions, the training loop, and every .to(device) call, indexing them by AST declarations using tree-sitter.
- why is my PyTorch training loop slower than it should be?
- Usually a tensor is still on the CPU and is forcing a device sync every step, often a running loss kept as a Python float or an .item() call inside the loop. Atlas locates the crossing points and reports them before proposing a fix.
- does Atlas add torch.compile to a PyTorch model?
- Yes. Atlas can add torch.no_grad around evaluation and wrap the model with torch.compile, then show you the throughput delta, so you can revert if compilation made things slower rather than assuming it helped.
- can Atlas run pytest on a PyTorch codebase?
- Yes. Atlas runs pytest behind a permission prompt and finishes with ruff format. Every tool call is permission-gated against allow, ask, and deny rules, so a full training job never starts on a GPU without your allow.
- can Atlas index PyTorch research code privately?
- Yes. Atlas can build its code index with local Ollama embeddings, keeping code off third-party servers, so your nn.Module definitions and training loop never leave your own hardware during indexing.
- does Atlas understand PyTorch DataLoader worker counts?
- Atlas treats DataLoader worker counts as part of the performance picture, alongside device placement and autograd, because in PyTorch those three cause most of the bugs and most of the slowness.
Try Atlas in your terminal
The terminal-native AI coding agent. Free core, single binary.
Install AtlasRelated guides
Locate Where a Behavior is Implemented in PyTorch with Atlas in 2026
Pinpoint the exact file and symbol responsible for a behavior in your PyTorch codebase using Atlas. Leverage semantic search, grep, and LSP tools for precise results.
Write Unit Tests for Untested PyTorch Code with Atlas in 2026
Add real unit tests to untested PyTorch modules using Atlas. Leverage pytest, uv, and ruff format to match existing repo conventions and ensure code quality.
Plan a Multi-File Change Before Editing in PyTorch with Atlas in 2026
Design and review complex, multi-file PyTorch changes with Atlas's plan agent before modifying a single line of code. Leverage real PyTorch tools like pytest and uv.
Rename a symbol across the repo in PyTorch with Atlas in 2026
Effortlessly rename PyTorch functions, classes, or constants across your entire codebase in 2026 with Atlas. Leverage lsp, grep, and edit for precise, verified refactoring.
Document a PyTorch Module with a README using Atlas in 2026
In 2026, Atlas helps PyTorch developers generate accurate READMEs for modules by analyzing live code, ensuring documentation reflects current device placement, autograd, and DataLoader configurations.
Refactor a legacy PyTorch module with Atlas in 2026
Restructure old PyTorch modules without breaking callers or changing behavior. Atlas uses `lsp` for callsite mapping, `pytest` for baselining, and `apply_patch` for safe code changes.
Onboard to an Unfamiliar PyTorch Codebase with Atlas in 2026
In 2026, Atlas helps PyTorch developers quickly build a mental model of new codebases. Pinpoint `nn.Module` definitions, identify device placement issues, and integrate with `pytest`, `uv`, and `ruff format` for
Automate GitHub Issue and Pull Request Triage in PyTorch with Atlas in 2026
Streamline PyTorch issue and PR triage with Atlas in 2026. Automate responses, run `pytest` and `ruff format` safely, and ensure trusted user control in your GitHub workflows.