Atlas Scout documentation

Current release and changes

This page documents the version currently named by the signed preview release pointer: 1.0.0-preview.9. Behavior present only on the source repository’s main branch is not described here as released behavior.

What changed

• Preview 9 safely recovers when a workspace is moved or copied together with its .atlas directory. Scout preserves the old generated cache, starts a fresh index for the new canonical location, and lets MCP initialization continue without manual cleanup.
• Preview 7 uses indexed identifier-token retrieval and semantics-aware import shortlisting before applying its full relationship matcher. Ambiguous imports remain unresolved rather than guessed.
• Preview 6 made component-reference queries more resilient, preserved JavaScript-family import provenance, clarified source coordinates and shared-reader health, and added a bounded convention-based test shortlist to edit-impact results.
• The Claude Code integration now has documented plugin and manual modes, session and subagent guidance, task recipes, non-interactive permissions, and CLI support.

The Firefox and Linux kernel benchmarks show where the new retrieval path pays off, including its up-front indexing and storage costs. They are measurements of named repositories, hardware, cache states, and workloads—not promises of one universal speedup or latency. See the changelog for the complete reader-facing release history.

What Atlas Scout is

Atlas Scout is a local, read-only code-navigation server for AI coding agents. It builds a compact structural map of your codebase and serves it over the Model Context Protocol (MCP), so an agent can find the right file, symbol, relationship, and exact source range before reading any code.

The principle is simple: an agent should never have to search or read a whole repository to answer a focused question. Scout answers with identifiers, relationships, provenance, and precise coordinates; the agent then reads only the ranges that matter, with its normal file tools. That covers the questions agents ask constantly: where is this implemented, what calls this function, what does this type depend on, which tests does this change touch, which few files should I read first?

Atlas Scout complements text search, compilers, language servers, and test runners — it does not pretend to replace them. It is proprietary software from Zaguán Labs.

Where it comes from: Atlas Scout began life inside Zaguán Blade as its Symbols Index. The idea proved strong enough to deserve its own product, so Scout was carved out and rebuilt as standalone navigation infrastructure. The two remain separate: Scout is developed and licensed on its own, and Blade does not include it.

The reference-first model

A map, not a second copy of your repository

Scout reads files locally and builds one generated SQLite index per workspace at .atlas/scout/symbols.db — ignored by git, excluded from discovery and watchers, and automatically kept out of your history (Scout writes a defensive .atlas/.gitignore and idempotently adds .atlas/ to the root .gitignore on first open). The index holds symbol identifiers, names, kinds, signatures and ranges; imports, calls, inheritance, implementation, containment and type-use relationships; semantic anchors like routes, configuration keys, and rationale comments; plus fingerprints and health metadata. It stores no duplicate source tree and no source-file bodies — discovery responses are coordinate-first, and the authoritative source is always read from your files.

Connected, and honest about it

Relationship resolution is precision-first. Scout records how each target was resolved and keeps genuinely ambiguous observations marked as unresolved instead of inventing certainty. That honesty is what makes call neighborhoods, shortest paths, and edit-impact estimates trustworthy enough for an agent to act on.

One map, shared by every client

Because the map lives in the workspace, Codex, Claude Code, the CLI, and editor integrations all reuse the same database — even as independent processes, with concurrent initialization and writes safely coordinated. One client can build or refresh the index and another can query it. If another process owns the writer lock, health reports index.shared_read_only while keeping reads available. The optional atlas-scoutd daemon adds warmth across workspaces and memory-only unsaved-buffer overlays; it is an optimization, not a requirement for sharing. The Neovim and VS Code overlay clients currently live in the source repository and are not included in the public Preview 9 release archives.

Bounded by design

Every result is bounded and carries truncation, freshness, coverage, and empty-result trust metadata — so an agent knows whether it has a complete answer, needs another page, or should fall back to another tool. Scout exists to shrink the working set, not to pour a repository-sized search result into a context window.

Direct or daemon-backed MCP

Your MCP host always launches atlas-scout mcp. That stdio adapter uses a compatible local atlas-scoutd automatically when one is available and runs a direct in-process server when one is not. Starting the daemon never changes the MCP registration command, and both arrangements use the same persistent workspace index.

Start direct when simplicity and saved-file navigation are enough. Add the daemon with atlas-scoutd --idle-seconds 600 when keeping workspaces warm or sharing unsaved editor state is valuable. atlas-scout doctor reports the resolved endpoint, protocol versions, and whether the stdio adapter fell back to direct mode.

The daemon accepts only a per-user local Unix socket or Windows named pipe. It is not a remote or Streamable HTTP MCP server, and it never owns a second index.

MCP tool reference

Six permanent Free tools; a Pro evaluation, subscription, grace period, or eligible fallback adds eight more — fourteen in total.

Free tools

Free tools are not rate-limited or made less accurate. They run on the same index, extraction, freshness checks, and ranking as Pro.

Pro tools

Compact defaults and expansion

Scout starts small on purpose. symbol_search returns five ranked results by default and supports a larger explicit limit plus cursors. symbol_outline defaults to twenty top-level declarations; request nesting, depth, locals, imports, kinds, or a larger limit only when the compact inventory is insufficient. fast_context likewise defaults to a compact projection; set detail="expanded" for its deeper evidence view.

Normal MCP responses are trimmed toward a 24 KiB target while preserving stable IDs, paths, source ranges, trust, and truncation metadata. Structured results also retain a text mirror for hosts that expose only MCP content.

Selectors, coordinates, and reference trust

symbol_references accepts either a copied symbol_id or an exact query scoped by path. For JSX and TSX components, incoming usage relationships include render-call consumers. Empty reference results still carry coverage and trust metadata; they are not proof that a symbol is unused.

MCP source ranges use one-based lines and zero-based characters. A relationship observation’s single line value is one-based. edit_impact combines structurally reached tests with at most twelve convention-related indexed test paths; that second shortlist is useful evidence, not an exhaustive test plan.

A practical workflow

1. If the exact file and range are known, read them directly.
2. If the file is known but the range is not, call symbol_outline.
3. If the location is unknown, call symbol_search with the strongest identifier or domain cue.
4. Resolve the chosen ID with symbol_resolve when exact metadata matters.
5. Use symbol_references for direct relationships.
6. Reach for graph, trace, path, impact, or architecture tools only when the question needs deeper connected evidence.
7. Read the exact ranges with your host’s file tool before editing.
8. Fall back to text or regex search for literals, generated text, or unsupported constructs.

For broad tasks, fast_context supplies the initial shortlist — then confirm the important relationships with the targeted tools.

Free and Pro

Free is permanent, local, and accountless — the complete index and relationship pipeline, every supported language at its documented level, the six Free tools, CLI indexing and diagnostics, the shared daemon, editor overlays, and unlimited ordinary workspaces. No artificial quotas of any kind. Free is a genuinely useful product, not a degraded demo. The overlay protocol is available in Free; the Neovim and VS Code clients themselves are not yet publicly distributed as packaged extensions.

Pro adds connected understanding: all eight advanced tools, multi-hop graph/trace/path analysis, edit impact, ranked fast context, and editor/unsaved-buffer signals in ranking. Pro is licensed to one named person on up to three installations — one installation covers the CLI, MCP clients, daemon, Neovim, and VS Code on that machine. Pro is available for $39/month or $390/year in USD; any applicable taxes and the final total are shown at checkout. See pricing and purchase options. Signed-in users can manage or cancel a subscription from their account, and the CLI’s license activate connects an installation to a license the account already holds.

The 14-day evaluation

Every verified user can start one 14-day Pro evaluation: no card, the complete feature set, no reduced trial variant. It begins only when you explicitly run the trial command — never at download, install, or first index. All installations on the account share one server-authoritative end time, and reinstalling or clearing local state does not restart it. When it ends, everything falls back to Free non-destructively.

Paid time vests into a permanent license

Every completed paid year becomes yours permanently: one paid annual term (once its refund window closes) grants perpetual Pro in every release issued on or before that term’s end — from your first year. Monthly subscribers earn the same guarantee after twelve consecutive paid periods, and every later renewal advances the cutoff. An active subscription keeps you on the newest releases; the earned license never expires, even if you cancel.

Licensing and offline behavior

Pro entitlements are signed, time-bounded leases verified locally — signature, product, installation, generation, release eligibility, and time bounds — before anything is enabled. The billing provider never controls feature checks inside the binary. What that means day to day:

• Free never contacts a license server.
• A cached Pro lease is verified locally at start; MCP startup never waits for the network.
• Pro works offline for the lease window (up to 30 days); outages never remove valid cached access.
• A missing renewal result gets a 24-hour settlement window; a confirmed payment failure gets a separate 14-day grace.
• Cancellation keeps Pro through the paid period.
• Upgrades, downgrades, expiry, and deactivation never delete or rebuild your index, and a running tool call is never interrupted.

atlas-scout license trial --label "My laptop"
atlas-scout license activate --label "My laptop"
atlas-scout license status [--json]
atlas-scout license refresh
atlas-scout license deactivate
atlas-scout license devices

--label is required on trial and activate — it is the name the installation shows on your devices page. license status is network-free and fully redacted: it reports edition, state, signed boundaries, and a support code — never a credential, token, identifier, or email.

Credentials are stored in the platform keychain by default (Secret Service or KWallet on Linux, Keychain on macOS, and Windows Credential Manager on Windows). On headless or minimal Linux systems without a keyring service — SSH sessions, containers, bare window managers — pass --credential-store file --credential-directory /absolute/private/dir to use the file backend instead; the directory should be dedicated and user-only.

Language support

Full structural extraction — definitions, imports, declared relationships, and semantic anchors: TypeScript, TSX, JavaScript, JSX, Python, Rust, Go.

Partial extraction is explicit and honest: a partial language contributes exactly the capabilities its extractor lists, and unsupported or failed files stay visible in health metadata rather than silently vanishing from coverage.

TypeScript, TSX, JavaScript, JSX, and Astro preserve named-import provenance, including aliases. Local relative imports plus @/ and ~/ root-style aliases resolve when the target is unambiguous; Scout fails closed when more than one target remains plausible. C/C++ coverage remains definitions-only rather than a complete call graph.

Editors, agents, and hosts

Atlas Scout speaks local MCP over stdio and has been exercised with Codex, Claude Code, Devin desktop environments, Antigravity, Cline, and OpenCode. Any compatible host that can start atlas-scout mcp works; cloud-only agents need Atlas Scout installed inside the environment where they run.

Claude Code: plugin mode

The preferred Claude Code integration is the plugin included at integrations/claude-code/atlas-scout in every full release archive. It uses server-level eager loading, so Claude receives the complete Scout tool schema. Advisory context is injected at SessionStart and SubagentStart, giving the main conversation and built-in or custom subagents the same navigation guidance.

The hooks retain no session state and never inspect, deny, retry, or modify a tool call. Claude’s normal tools remain available for direct known-range reads, literals, regexes, unsupported coverage, builds, tests, Git, runtime work, and focused fallback.

The binary-only install.sh flow does not retain plugin assets. To use plugin mode, download and verify the full platform archive named by latest.json, extract it to a stable directory, ensure atlas-scout is on PATH, and start a new session with claude --plugin-dir /stable/path/integrations/claude-code/atlas-scout. Remove or disable a duplicate manually registered atlas-scout server while the plugin is active.

Claude Code: manual MCP mode

Manual user-level registration remains supported. In this mode, symbol_search, symbol_outline, and symbol_referencesstay visible as routing tools while the remaining tools are deferred. This three-tool behavior is separate from the plugin’s server-level eager loading.

No prompt command is required for normal use. For diagnosis, /mcp__atlas-scout__atlas_scout_symbols_workflow injects the canonical workflow. /mcp__atlas-scout__atlas_scout_task_recipes adds compact recipes for consolidating a duplicated feature, finding UI consumers, and tracing display code to a server mutation. If the server has another configured name, use that normalized name in the command.

claude --append-system-prompt "$(atlas-scout claude-code print-system-prompt)"
claude -p "<prompt>" --allowedTools 'mcp__atlas-scout__*'

The first command opts into stronger Scout guidance without replacing Claude Code’s default safety prompt. Non-interactive Claude must explicitly allow mcp__atlas-scout__*; otherwise dontAsk denies the calls and encourages built-in-tool fallback.

Other local MCP hosts

Codex uses codex mcp add atlas-scout -- /absolute/path/to/atlas-scout mcp. Devin, Antigravity, and Cline accept the common mcpServers shape with the binary as command and ["mcp"] as args. OpenCode uses a local MCP entry whose command array is ["/absolute/path/to/atlas-scout", "mcp"]. Restart or refresh the host after replacing the binary or changing configuration.

Approve or auto-approve only the trusted Atlas Scout server if uninterrupted navigation is desired. Do not enable a global all-tools or YOLO permission mode merely to remove Scout prompts.

In Devin, once Atlas Scout is installed and active, enable the Disable fast context agenttoggle in settings (“Stops the fast context agent from running parallel searches as a subagent”). Devin’s fast context agent duplicates the navigation work Scout already does with indexed, structural answers — turning it off removes the competing parallel searches and lets Scout be the single navigation path.

Editor overlays

The source repository contains Neovim and VS Code clients that feed memory-only unsaved-buffer overlays to atlas-scoutd. They are thin local clients, not competing indexes, but Preview 9 does not package them or publish them through editor marketplaces. Treat them as source-tree integrations rather than immediately installable public extensions.

Getting started

Atlas Scout ships as an unsigned technical preview with full cryptographic verification — checksums, OpenPGP signatures, and Sigstore build provenance; organization-signed builds follow later. Releases are served from download.atlasscout.dev, and the pointer preview/latest.json always names the current release and links its manifest, signatures, public key, and checksums.

Linux and macOS

curl -fsSL https://atlasscout.dev/install.sh -o install.sh
sh install.sh

The installer detects your OS and architecture (Linux x86-64 and ARM64, macOS Apple Silicon), downloads the matching artifact, verifies its SHA-256 checksum — plus the OpenPGP signature over SHA256SUMS when gpg is available — and installs to ~/.local/bin. Pin a release with ATLAS_SCOUT_VERSION, or change the destination with ATLAS_SCOUT_INSTALL_DIR.

Windows

There is no scripted installer yet. Download atlas-scout-<version>-x86_64-pc-windows-msvc.zip from the release directory referenced by latest.json, verify its SHA-256 against SHA256SUMS from the same directory (Get-FileHash in PowerShell), extract it, and add the folder to your PATH. Read the preview notes before running it.

For agents: a machine-readable install-and-usage skill lives at atlasscout.dev/atlas-scout.md — an agent can fetch it and follow it end to end. The OS-detecting installer it references is atlasscout.dev/install.sh (checksum- and signature-verified, version overridable via ATLAS_SCOUT_VERSION).

Index and diagnose

atlas-scout index /absolute/path/to/project
atlas-scout doctor --workspace /absolute/path/to/project

Pre-warming is optional — MCP initialization never waits for a repository walk. index and doctor use concise human-readable output by default; add --json for strict JSON or --machine for the legacy key/value contract. doctor reports the resolved workspace, cache location, coverage, resource profile, daemon endpoint, ready-to-paste host setup, product version, daemon protocol, MCP wire schema, database schema, and upstream MCP protocol revision. These are independent compatibility contracts rather than one shared version number.

Connect Claude Code manually

claude mcp add --scope user --transport stdio atlas-scout -- \
  /absolute/path/to/atlas-scout mcp

This is the manual MCP mode. For the full eager-loaded plugin mode, retain the plugin directory from a verified release archive and follow the Claude Code plugin instructions above.

Connect Codex

codex mcp add atlas-scout -- /absolute/path/to/atlas-scout mcp

Without an explicit --workspace, Scout resolves the active project from ATLAS_SCOUT_WORKSPACE, then CLAUDE_PROJECT_DIR, then the MCP working directory. Each workspace stores one database at .atlas/scout/symbols.db, shared by every local client; it is generated state — never commit it or copy it between workspaces. For read-only checkouts or CI, --cache-dir / ATLAS_SCOUT_CACHE_DIR opt into an external location (all sharing clients must use the same override). Start the shared daemon with atlas-scoutd --idle-seconds 600; MCP discovers it automatically and falls back to a direct process on the same workspace database.

CLI at a glance

Operations and recovery

Advanced indexing and resource controls

Select a resource profile with ATLAS_SCOUT_INDEX_MODE=lean|balanced|full; balanced is the default. lean tightens memory and per-file bounds, while full raises them for larger source files. ATLAS_SCOUT_MAX_INFLIGHT_MIB sets the bounded in-flight extraction budget.

ATLAS_SCOUT_INDEX_WORKERS is an advanced host-tuning override. Benchmark a pinned corpus before keeping it: once extraction outruns the single database writer, more workers can consume more memory and make a complete index slower. doctor reports the active settings, and settings that change index content participate in freshness identity.

Reliability and failure behavior

• Cold or incomplete indexes report honest health instead of blocking MCP initialization.
• Unsupported, failed, stale, indexing, and fresh-empty states remain distinguishable.
• A corrupt generated database is quarantined and rebuilt.
• A valid workspace-local cache carried to a new canonical root is preserved and replaced with a fresh index automatically.
• A disconnected or incompatible daemon falls back to a direct local MCP process rather than serving an incompatible schema.
• SQLite transactions, coordinated writers, and bounded parsing keep partial writes or one pathological file from stalling the complete index indefinitely.
• Any license failure preserves Free indexing and navigation; expiry and downgrade change tool admission without deleting repository or index data.

Moving or copying a workspace

If a move or copy carries .atlas to a different canonical root, Scout does not rewrite or reuse the possibly live SQLite and WAL state from the old location. It preserves the complete valid cache as .atlas/scout.relocated-<workspace-id>, creates a fresh .atlas/scout/, and continues initialization. Workspace setup is serialized through .atlas/setup.lock, so concurrent clients agree on the recovery.

atlas-scout doctor lists preserved relocation archives. They remain ignored local generated data until you choose to remove them. Malformed identity metadata, symlinks, rename failures, and explicit external-cache collisions remain hard errors; Scout leaves that state in place instead of guessing.

Large repositories and timeouts

1. Pre-warm the workspace with atlas-scout index /absolute/path/to/project.
2. Raise the host’s MCP startup or tool timeout when the repository justifies it.
3. Confirm the current state with atlas-scout doctor; a host-side timeout is not proof that Scout failed.

Update and restart

1. Rerun the verified installer, or verify and replace a manually installed binary.
2. Restart atlas-scoutd and start new MCP host sessions. Replacing a binary does not kill running processes; they continue using the old executable until restarted.
3. Run atlas-scout doctor after the update. Append-only database migrations run automatically, and ordinary updates leave the workspace index intact.
4. Rebuild only when diagnostics report a compatibility or corruption problem, rather than deleting the index after every update.

Uninstall

Stop Scout processes, remove the host registration (for example, claude mcp remove atlas-scout or codex mcp remove atlas-scout), and remove atlas-scout and atlas-scoutdfrom their install directory. Workspace indexes contain no user-authored state; after every Scout process has stopped, you may optionally remove each workspace’s .atlas/ directory and its .atlas/ entry in .gitignore. If you used an external cache override, doctor identifies the namespaced directory to remove.

Atlas Scout is an unsigned technical preview

The macOS and Windows binaries do not yet carry Apple or Microsoft publisher signatures. Cryptographic checks prove the downloaded bytes and their build provenance, but they do not provide native publisher trust or an operating-system malware review. If you would rather not run unsigned software, that is a reasonable choice — you can safely wait for the future organization-signed stable release.

Verify before you run. Before executing a downloaded artifact — and before approving any per-file security exception for it — verify the complete candidate: check it against SHA256SUMS, verify the OpenPGP signatures, and verify the artifact’s Sigstore provenance bundle. The release public key (fingerprint CA35 C410 D8C7 FE04 8504 6A66 704C 70AA 814F 6D2E), the signed release manifest, and the checksums ship alongside every release on download.atlasscout.dev, all reachable from preview/latest.json.

macOS

The supported install path is curl-and-tar (our installer). Apple documents that curl does not quarantine downloaded files and tar does not propagate quarantine while extracting, so the scripted install normally runs without a first-launch Gatekeeper prompt. “Normally” is the honest word: Apple also states that Gatekeeper can run at other times and that the exact circumstances are not documented and can change, so we do not promise a warning-free install. Either way, the binary remains unsigned and unnotarized.

Downloading manually with Safari or another quarantine-aware downloader can attach com.apple.quarantine, and Finder or another user-level unarchiver can propagate it to the extracted files — Gatekeeper will then say the developer cannot be verified or that Apple cannot check the software for malicious content. If that happens for an artifact you have verified, dismiss the warning for only that executable, then use System Settings → Privacy & Security → Open Anyway for that one item, and confirm Open only if the displayed item is the one you just verified.

Two hard rules. Never override an alert that says the software will damage your computer, contains malware, is damaged, or has been modified — that is not the unsigned-developer warning, and the answer is to delete the file. And our installer never removes quarantine attributes: if a guide or a coding agent suggests xattr -d com.apple.quarantine, decline.

Windows

Microsoft Defender SmartScreen may show “Windows protected your PC.” If it offers More info → Run anyway for a verified Atlas Scout executable, that choice applies to that item only; likewise, apply the file Properties Unblock checkbox only per verified executable. Smart App Control in enforcement mode may block the unsigned executable without offering a per-file exception — do not disable that protection. Use an unmanaged supported device or wait for the signed stable release.

Linux

Linux does not use the Apple or Microsoft publisher-signing systems, but the same rule stands: verify the complete candidate — checksums, OpenPGP, Sigstore — before making anything executable, and do not run a file whose checksum differs.

Managed devices and global protections

Managed or strictly configured devices may block unsigned software. Atlas Scout does not ask you to bypass an administrator or organization policy — ever. And never globally disable Gatekeeper, Microsoft Defender SmartScreen, Smart App Control, antivirus, endpoint security, or organization policy on Atlas Scout’s account: every accommodation above is strictly per verified file.

Privacy and security

Atlas Scout never sends your repository anywhere. Indexing, graph resolution, ranking, and every MCP query run locally. Licensing requests never contain source code, docstrings, paths, filenames, symbol names, queries, tool calls, editor state, git remotes, or index metrics — only the minimal account, installation, release, and rotating-credential data needed to issue a signed lease. A never-activated Free installation makes no network requests at all; an installation that was activated in the past may keep attempting asynchronous license refreshes after falling back to Free.

The one boundary that is not ours: Scout hands navigation results — paths, symbol names, bounded code ranges — to the coding agent you connect it to. If that agent is cloud-hosted, its provider receives those requests and results under your agreement with that provider. That traffic belongs to the agent, not to Atlas Scout.

Read-only toward your source files, and non-executing. Every tool is read-only, idempotent, and closed-world. Scout never executes repository code, package scripts, builds, tests, or git hooks, and never edits your source files — it writes its own index and, for a default local index, appends .atlas/ to the workspace .gitignore once. Reads are constrained to the workspace root, and symlinks pointing outside it are not followed by default. The index lives under the ignored .atlas/scout/ directory by default (relocatable with --cache-dir / ATLAS_SCOUT_CACHE_DIR) with user-only permissions, holds structural records and coordinates rather than source bodies, and can be deleted and rebuilt at any time. There is no mandatory telemetry of any kind.

Current limitations

• Local stdio MCP only — no remote or streamable HTTP transport yet.
• Disk is authoritative unless a supported editor overlay supplies a newer unsaved buffer.
• Relationships are static, flow-insensitive, and precision-first — Scout is not a compiler, type checker, or runtime tracer, and ambiguous targets stay unresolved.
• Semantic anchors are heuristic evidence, not graph edges.
• C/C++ is definitions-only; partial-scanner languages do not match the full extractors’ precision.
• Cross-repository navigation is not yet a public workflow.
• Bounded results can require pagination or narrower follow-ups; exact literals may still need text search.
• Scout selects and describes ranges — reading, editing, and validating remain yours (or your agent’s).

Frequently asked questions

Does Atlas Scout upload my repository?

No. Indexing and navigation happen locally. License requests never include repository content, identity, paths, symbols, queries, or usage data.

Does it modify my source code?

No. Every MCP tool is read-only and Scout never executes project code or hooks. On first open it creates the ignored .atlas/ directory and idempotently adds .atlas/ to your .gitignore — it does not touch source files.

Is it an AI model?

No. Atlas Scout is deterministic local navigation infrastructure for AI agents. The connected agent decides how to use the evidence Scout returns.

Does it replace text search?

No — it replaces text search only where text search is the wrong tool. Structural questions (definitions, callers, paths, impact) go to Scout; exact literals, regexes, and unsupported constructs still belong to grep.

Is it a language server or compiler?

No. It is a persistent multi-language structural map optimized for bounded agent queries. It does not build, type-check, or claim compiler-level completeness.

Does Free use a worse index?

No. Free and Pro share the same extraction, indexing, relationship resolution, freshness, and ranking. Pro unlocks deeper connected-analysis tools, never index quality.

Do I need an account for Free?

No. Free is permanent and accountless. A verified account is needed only for the Pro evaluation or a paid subscription.

What happens when my trial or subscription ends?

Atlas Scout falls back non-destructively to Free (or to an earned perpetual fallback). Index, settings, and integrations are kept; a later purchase unlocks Pro again with no reindex.

Can it work offline?

Yes. Free never needs a network. Pro runs from a locally verified cached lease for up to 30 days; refresh is asynchronous and never blocks startup.

Why ranges instead of whole files?

Coordinates, stable IDs, and relationships cost far fewer tokens than embedded source. The agent reads exactly the ranges that matter — that is the point.

Can several agents share one index?

Yes — automatically. All local agents, CLI processes, and editors on the same workspace share .atlas/scout/symbols.db, even as independent processes. The optional atlas-scoutd daemon adds warmth and editor overlays; it does not own a separate index. A Pro license covers one named person on up to three installations.

How do I reset the index?

Confirm the database path with atlas-scout doctor, stop Atlas Scout processes, remove .atlas/scout/, and index again. The index holds no user-authored state — but never remove the directory while a client or daemon is writing to it.

Product principles

Return evidence, not guesses. Prefer coordinates over bulk source. Keep results bounded and explain truncation. Report the unsupported and unresolved honestly. Keep repository data local, never execute it. Keep Free useful and permanent — gate advanced tools, never index quality or user data. And preserve Free access and local data through every license failure or downgrade.