Atlas is a terminal-native AI coding agent for Deno, whose permission flags and batteries-included toolchain match how Atlas already gates every tool call. Run atlas in a project with a deno.json or deno.jsonc, and Atlas reads your imports map, JSR and npm specifiers, and the tasks defined in the config. Every Atlas tool call is permission-gated against allow, ask, and deny rules before it runs, which is the same model Deno applies to your program, so the agent and the runtime agree about what is allowed.
Why Deno developers use Atlas
Deno developers use Atlas because both tools reason about permissions rather than trusting code by default. Deno decides what a program may touch through flags like --allow-net and --allow-read, and every Atlas tool call is gated against 3 rules, allow, ask, and deny, before it runs.
Deno projects put their whole surface in one place. A deno.json or deno.jsonc holds the imports map, the JSR and npm specifiers, and the tasks, so an agent that reads that file knows how the project is built, tested, and run. Atlas searches code with hybrid semantic and keyword retrieval fused by reciprocal rank fusion and indexes code by AST declarations using tree-sitter, not blind line windows, so a request like which module actually opens a socket returns the call site rather than every file importing something network-shaped. That precision is what makes permission tightening possible instead of guesswork.
Tightening --allow-all down to real permission scopes
Ask Atlas to tighten a broad --allow-all task down to the specific --allow-net and --allow-read scopes the code really needs. Deno permission flags are only useful when they are narrow, and in 2026 an --allow-all task still turns the whole Deno security model off for that command.
Almost every Deno project starts with --allow-all in a task because narrowing the flags by hand means auditing every fetch, every Deno.readTextFile, and every environment lookup in the dependency graph. That audit is exactly what a code index is good at. Atlas traces the network and filesystem calls the task actually reaches, then proposes the specific --allow-net and --allow-read scopes to replace the blanket flag. Atlas computes a unified diff for every file edit and surfaces it for approval before writing, so the rewritten deno.json task is reviewed before it replaces the permissive one.
Managing JSR and npm specifiers in Deno
Atlas adds dependencies with deno add jsr:@std/... rather than hand-editing the import map. Running deno add writes the specifier into deno.json correctly and resolves the version, while a hand-edited imports map is how a project ends up with 2 versions of the standard library at once.
Deno's module resolution is explicit, which is a strength until someone edits the imports map by hand. Atlas reads your imports map, JSR and npm specifiers, and the tasks defined in the config, so when a change needs a new dependency it reaches for deno add jsr:@std/... rather than pasting a URL. Because Atlas is asked to run commands rather than fabricate config, the resulting deno.json is what Deno itself would have written. Atlas snapshots file changes as git patches so edits can be diffed and rolled back if a specifier bump breaks a task.
Working in Deno day to day with deno test and deno check
Atlas runs deno test and deno check behind a permission prompt, then applies deno fmt and deno lint to the diff. Deno ships all 4 of those commands in one binary, so an agent working in a Deno repo has a complete verification loop without installing a single extra dev dependency.
The Deno toolchain removes the usual argument about which formatter or test runner a project uses. deno check catches the type errors, deno test runs the suite, deno fmt normalizes the diff, and deno lint catches the rest. Atlas drafts a plan in a read-only plan agent and asks before switching to a build agent, so the loop is: plan, approve, edit, then run deno test and deno check behind a permission prompt. Atlas fans out work to subagents that can run in the foreground or in parallel background sessions when several modules need the same treatment.
Review and safety in a Deno project
Atlas computes a unified diff for every file edit and surfaces it for approval before writing, so in a Deno project every change to deno.json, an imports map entry, or a permission flag is read before it lands. Widening --allow-net by 1 host is a security decision, not a refactor.
Permission changes deserve the most scrutiny of any diff in a Deno repo, because widening --allow-net by one host is a security decision, not a refactor. Atlas surfaces those edits as unified diffs and gates its own execution against allow, ask, and deny rules, so it cannot quietly run a task with broader permissions than you approved. After deno fmt and deno lint have run over the change, the commit that lands contains the narrowed permission scopes and the code changes that justify them together.
Getting started
- 01Run atlas in a project with a deno.json or deno.jsonc.
- 02Let Atlas read your imports map, JSR and npm specifiers, and the tasks defined in the config.
- 03Ask Atlas to tighten a broad --allow-all task down to the specific --allow-net and --allow-read scopes the code really needs.
- 04Let Atlas add dependencies with deno add jsr:@std/... rather than hand-editing the import map.
- 05Have Atlas run deno test and deno check behind a permission prompt, then deno fmt and deno lint the diff.
Frequently asked questions
- how to use an AI coding agent with deno
- Run atlas in a project with a deno.json or deno.jsonc. Atlas reads your imports map, JSR and npm specifiers, and the tasks defined in the config, then proposes edits as unified diffs you approve.
- how do I replace --allow-all with specific deno permissions
- Ask Atlas to tighten a broad --allow-all task down to the specific --allow-net and --allow-read scopes the code really needs. Atlas traces the actual call sites and shows the rewritten task as a diff.
- how do I add a JSR dependency in deno
- Let Atlas add dependencies with deno add jsr:@std/... rather than hand-editing the import map, so deno.json is written the way Deno itself would write it.
- can an AI agent run deno test and deno check for me
- Yes. Atlas runs deno test and deno check behind a permission prompt, then applies deno fmt and deno lint to the diff.
- is an AI coding agent safe to use in a deno project
- Every Atlas tool call is permission-gated against allow, ask, and deny rules before it runs, which mirrors Deno's own permission model, and every file edit arrives as a unified diff.
- does Atlas send my deno source code to a third party
- Not necessarily. Atlas can build its code index with local Ollama embeddings, keeping code off third-party servers.
Try Atlas in your terminal
The terminal-native AI coding agent. Free core, single binary.
Install AtlasRelated guides
Refactor a Legacy Deno Module with Atlas in 2026
Safely refactor legacy Deno modules in 2026 without breaking callers. Atlas uses `deno test`, `deno fmt`, and `deno.json` to ensure structural changes preserve behavior and API contracts.
Review a Pull Request in Deno with Atlas in 2026
In 2026, Deno developers use Atlas to review pull requests, leveraging its deep understanding of `deno.json` and `deno test`. Catch subtle bugs by examining full file context and verifying changes with Deno's built-in
Document a Deno Module with a README in 2026
In 2026, Atlas helps Deno developers generate accurate README documentation directly from source code. Leverage deno test, deno fmt, and JSR with AI-driven code analysis.
Run Atlas Headless in CI with Deno in 2026
Automate Atlas in your Deno CI pipelines for non-interactive code generation and refactoring. Get machine-readable JSON output, pre-approve Deno toolchain commands like deno test and deno fmt, and ensure secure
Rename a symbol across the repo in Deno with Atlas in 2026
Refactor Deno code with Atlas to rename functions, classes, or constants across your repository. Atlas uses Deno's LSP for precise renames, ensuring all references are updated, including those in comments and strings
Automate GitHub Issue and Pull Request Triage in Deno with Atlas in 2026
Streamline GitHub issue and pull request triage in your Deno projects using Atlas. Leverage Deno's built-in toolchain for secure, permission-gated AI automation directly from GitHub Actions.
Trace a runtime bug from a stack trace in Deno with Atlas in 2026
Pinpoint Deno runtime bugs from production stack traces to a fix using Atlas. Go from a raw stack trace to the exact line of code and a solution, leveraging Deno's toolchain and Atlas's AI without a debugger.
Debug a Single Failing Test in Deno with Atlas in 2026
In 2026, Deno developers use Atlas to efficiently debug single failing tests. Pinpoint issues in your Deno codebase, fix code, and ensure quality with Atlas's AI-powered agent, integrating direct with `deno test`